Ascii python: Кодирование строк символов ASCII в Python

Кодирование строк символов ASCII в Python

Рассмотрим несколько примеров, демонстрирующих основы кодирования строк в Python. Строки символов ASCII являются простейшей разновидностью строк символов Юникода, которые хранятся как последовательности байтов, представляющих символы:

>>> ord(‘X’) # В кодировке по умолчанию ‘X’ имеет значение 88
88
>>> chr(88) # Код 88 соответствует символу ‘X’
‘X’

>>> S = ‘XYZ’ # Строка Юникода из символов ASCII
>>> S
‘XYZ’

>>> len(S) # 3 символа
3

>>> [ord(c) for c in S] # 3 байта с целочисленными значениями
[88, 89, 90]

Обычный текст, состоящий только из 7-битовых символов ASCII, как в данном примере, представляется как последовательность байтов в любых схемах кодирования Юникода, о чем уже говорилось выше:

S = ‘XYZ’

>>> S. encode(‘ascii’) # Значения 0..127 в 1 байте (7 битов) каждое
b’XYZ’

>>> S.encode(‘latin-1’) # Значения 0..255 в 1 байте ( 8 битов) каждое
b’XYZ’

>>> S.encode(‘utf-8′) # Значения 0..127 в 1 байте, 128..2047 — в 2, другие в 3 или 4
b’XYZ’

Ваша мечта – стать лидером любимой соцсети или вывести свою группу в топ? Старт получился удачным, но СММ продвижение стало притормаживать. Настала пора искать свежие идеи, нужен новый взгляд. Загляните на этот портал, чтобы освежить знания по СММ продвижению в социальных сетях, узнать о новинках и секретах успеха, познакомиться с опытом, который придаст ускорение.

Фактически объекты типа bytes, возвращаемые данной операцией кодирования строки символов ASCII, в действительность являются последовательностью коротких целых чисел, которые просто выводятся как символы ASCII, когда это возможно:

S = ‘XYZ’

>>> S.encode(‘latin-1’)[0]
88

>>> list(S.encode(‘latin-1’))
[88, 89, 90]

Исчерпывающее руководство по Юникоду и кодировке символов в Python

Работа с кодировкой символов на Python, да и на любом другом языке, временами выглядит довольно сложной. На Stack Overflow можно найти тысячи вопросов, посвящённых таким исключениям, как UnicodeDecodeError и UnicodeEncodeError. Данное руководство призвано прояснить сложные аспекты работы с этими исключениями и продемонстрировать, что работа с текстовыми и двоичными данными на Python 3 может быть приятной. В Python хорошо реализована поддержка Юникода, однако для работы с кодировкой всё же потребуется приложить усилия.

Вводная часть статьи даст общее понимание работы с Юникодом, не привязанное к какому-то определённому языку, однако практические примеры будут приведены именно на Python, а их описание будет довольно лаконичным.

Изучив эту статью, вы:

• Освоите концепции кодировки символов и системы нумерации;
• Поймёте, как кодировка работает с объектами str и bytes;
• Узнаете, как в Python поддерживается система нумерации посредством различных форм литералов int;
• Познакомитесь со встроенными функциями языка, относящимися к кодировке и системе нумерации.

Система нумерации и кодировка символов настолько тесно связаны, что их придётся раскрыть в одном руководстве, в противном случае материал будет неполным.

Прим. Статья ориентирована на Python 3, а все примеры кода созданы с помощью оболочки CPython 3.7.2. Большая часть более ранних версий Python 3 также будут корректно обрабатывать код. Если вы всё ещё используете Python 2 и различия в обработке текста и бинарных данных между 2 и 3 версиями языка вас отпугивают, это руководство может помочь вам преодолеть барьер.

Что такое кодировка символов?

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

Независимо от того, занимаетесь вы самообразованием или получили более формальное образование в сфере IT , наверняка пару раз вы уже видели таблицу ASCII. Эта таблица — хорошее начало для изучения принципов кодировки, так как она простая и маленькая (как вы увидите дальше, даже слишком маленькая).

Она охватывает следующее:

• Символы английского алфавита в нижнем регистре: от a до z;
• Символы английского алфавита в верхнем регистре: от A до Z;
• Некоторые знаки препинания и символы: например «$» или «!»;
• Символы, отображаемые как пустое место: пробел (« »), символ новой строки, возврата каретки, горизонтальной и вертикальной табуляции и несколько других;
• Некоторые непечатаемые символы: такие как бекспейс, «\b», которые просто невозможно отобразить, так, как к примеру, букву А.

Приведём формальное определение кодировки символов.

На самом высоком уровне — это способ перевода символов (таких как буквы, знаки пунктуации, служебные знаки, пробелы и контрольные символы) в целые числа и затем непосредственно в биты. Каждый символ может быть закодирован уникальным двоичным кодом. Если вы плохо знакомы с концепцией битов, не волнуйтесь, мы вскоре о ней поговорим.

Группы символов выделяют в отдельные категории. Каждому символу соответствует кодовая точка, которую можно рассматривать просто как целое число. В таблице ASCII символы сегментированы следующим образом:

Всего кодировка ASCII содержит 128 символов. В таблице ниже вы видите исчерпывающий набор знаков, которые позволяет отобразить эта кодировка. Если вы не видите какого-то символа, значит вы просто не сможете его вывести с помощью ASCII.

Кодовая точка	Символ (имя)	Кодовая точка	Символ (имя)
0	NUL (Null)	64	@
1	SOH (Start of Heading)	65	A
2	STX (Start of Text)	66	B
3	ETX (End of Text)	67	C
4	EOT (End of Transmission)	68	D
5	ENQ (Enquiry)	69	E
6	ACK (Acknowledgment)	70	F
7	BEL (Bell)	71	G
8	BS (Backspace)	72	H
9	HT (Horizontal Tab)	73	I
10	LF (Line Feed)	74	J
11	VT (Vertical Tab)	75	K
12	FF (Form Feed)	76	L
13	CR (Carriage Return)	77	M
14	SO (Shift Out)	78	N
15	SI (Shift In)	79	O
16	DLE (Data Link Escape)	80	P
17	DC1 (Device Control 1)	81	Q
18	DC2 (Device Control 2)	82	R
19	DC3 (Device Control 3)	83	S
20	DC4 (Device Control 4)	84	T
21	NAK (Negative Acknowledgment)	85	U
22	SYN (Synchronous Idle)	86	V
23	ETB (End of Transmission Block)	87	W
24	CAN (Cancel)	88	X
25	EM (End of Medium)	89	Y
26	SUB (Substitute)	90	Z
27	ESC (Escape)	91	[
28	FS (File Separator)	92	\
29	GS (Group Separator)	93	]
30	RS (Record Separator)	94	^
31	US (Unit Separator)	95	_
32	SP (Space)	96	`
33	!	97	a
34	"	98	b
35	#	99	c
36	$	100	d
37	%	101	e
38	&	102	f
39	'	103	g
40	(	104	h
41	)	105	i
42	*	106	j
43	+	107	k
44	,	108	l
45	-	109	m
46	.	110	n
47	/	111	o
48	0	112	p
49	1	113	q
50	2	114	r
51	3	115	s
52	4	116	t
53	5	117	u
54	6	118	v
55	7	119	w
56	8	120	x
57	9	121	y
58	:	122	z
59	;	123	{
60	<	124	|
61	=	125	}
62	>	126	~
63	?	127	DEL (delete)

Модуль string

Модуль string — простой и удобный инструмент, разграничивающий содержащиеся в ASCII символы по группам, разделяя их в строки-константы. _`{|}~»»»
printable = digits + ascii_letters + punctuation + whitespace

Большинство этих констант исчерпывающе описаны их идентификаторами. Мы вкратце коснёмся констант hexdigits и octdigits.

Мы можем использовать определённые в модуле константы для рутинных операций:

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'

Прим. Обратите внимание, string.printable включает string.whitespace. Это несколько не соответствует тому, как печатаемые символы определяет метод str.isprintable(), который не рассматривает ни один из символов {'\v', '\n', '\r', '\f', '\t'} как печатаемый.

Это различие происходит из определения метода: str.isprintable() рассматривает что-либо печатаемым, если «все символы рассматриваются как печатаемые методом repr().

Что такое биты

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

Бит — это сигнал, который имеет два возможных состояния. Есть различные способы символического отображения этих состояний:

• 0 или 1;
• «да» или «нет»;
• True или False;
• «включено» или «выключено».

Таблица ASCII из предыдущего раздела использует то, что обычно назвали бы числами (от 0 до 127), однако для наших целей важно понимать, что это десятичные числа (с основанием 10).

Каждое из этих десятичных чисел можно выразить последовательностью бит (числом с основанием 2). Вот таблица соотношения двоичных и десятичных чисел:

Обратите внимание, что при увеличении десятичного числа n для его отображения (а следовательно и для отображения символа, относящегося к этому числу) требуется всё больше значимых бит.

Вот удобный метод представить строки ASCII как последовательность бит. Каждый символ из строки ASCII переводится в последовательность из 8 нолей и единиц с пробелами между этими последовательностями:

>>> def make_bitseq(s: str) -> str:
...     if not s.isascii():
...         raise ValueError("ASCII only allowed")
...     return " ".join(f"{ord(i):08b}" for i in s)

>>> make_bitseq("bits")
'01100010 01101001 01110100 01110011'

>>> make_bitseq("CAPS")
'01000011 01000001 01010000 01010011'

>>> make_bitseq("$25.43")
'00100100 00110010 00110101 00101110 00110100 00110011'

>>> make_bitseq("~5")
'01111110 00110101'

Прим. Обратите внимание, что метод .isascii() появился в Python 3.7.

Строковой литерал f-string f"{ord(i):08b}" использует мини-язык форматирования Format Specification Mini-Language, а именно его возможность замещения полей при форматировании строк.

• левая часть выражения, ord(i), представляет объект, значение которого будет отформатировано и отображено при выводе. ord() возвращает кодовую точку одиночного символа str в десятичном выражении;
• Правая сторона выражения определяет форматирование объекта. 08 означает ширина 8, заполнение нулями, а b работает как команда вывести число в двоичном (binary) эквиваленте.

На самом деле этот метод можно использовать разве что для развлечения. Он выдаст ошибку для любого символа, не представленного в ASCII-таблице. Позже мы рассмотрим, как эта проблема решается в других кодировках.

Нам нужно больше бит

Исходя из определения бита, можно вывести следующую закономерность: при определённом количестве бит n с их помощью можно выразить 2ⁿ разных значений.

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits

Вот что это означает:

• 1 бит позволяет выразить 2¹ == 2 возможных значения;
• 8 бит позволяют выразить 2⁸ == 256 возможных значений;
• 64 бита позволяют выразить 2⁶⁴ == 18 446 744 073 709 551 616 возможных значений.

В качестве естественного вывода из приведённой выше формулы мы можем установить следующее: для того, чтобы вычислить количество бит, необходимых для выражения определённого числа разных значений, нам нужно найти n в уравнении 2ⁿ=x, где переменная x известна.

Вот как можно это рассчитать:

>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
...     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8

Округление вверх в методе n_bits_required() требуется для расчёта значений, которые не являются чистой степенью двойки. К примеру, вам нужно сохранить набор из 110 различных символов. Для этого потребуется log(110) / log(2) == 6.781 бит, но поскольку бит для вычислительной техники является мельчайшей неделимой величиной, для отображения 110 различных значений нам понадобится 7 бит, при этом несколько значений останутся невостребованными.

>>> n_bits_required(110)
7

Всё сказанное служит для обоснования одной идеи: ASCII, строго говоря, семибитная кодировка. Эта таблица содержит 128 кодовых точек, и, соответственно, символов, от 0 до 127 включительно. Это требует 7 бит:

>>> n_bits_required(128)  # от 0 до 127
7
>>> n_possible_values(7)
128

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

Прим. В этой статье под байтом подразумевается группа из 8 бит, как повелось с 60-х годов прошлого века. Если вам не по душе это новомодное название, можете называть их октетами.

То, что ASCII-таблица использует 7 бит из доступных 8, означает, что память вычислительного устройства, занятого строками символов ASCII, наполовину пуста. Для того, чтобы лучше понять, почему это происходит, вернитесь к приведённой выше таблице соответствия двоичных и десятичных чисел. Вы можете выразить числа 0 и 1 с помощью 1 бита, или вы можете использовать 8 бит, чтобы выразить их как 00000000 и 00000001 соответственно.

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

Вы можете выразить числа от 0 до 3 всего двумя битами, от 00 до 11, или использовать 8 бит, чтобы выразить их как 00000000, 00000001, 00000010 и 00000011. Самая большая кодовая точка ASCII, 127, требует только 7 значимых бит.

С учётом этого взгляните, как метод make_bitseq() преобразует строки ASCII в строки, состоящие из байт, где каждый символ требует один байт:

>>> make_bitseq("bits")
'01100010 01101001 01110100 01110011'

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

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

Со временем появилась одна большая схема кодировки, которая объединила их. Однако, прежде чем мы до этого доберёмся, поговорим немного о краеугольных камнях схем кодировки символов — системах счисления.

Изучаем основы: другие системы счисления

В ASCII-таблице, как мы увидели, каждый символ соответствует числу от 0 до 127.

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

Однако существуют и другие системы счисления, которые, в частности, широко используются в исходном коде CPython. Следует понимать, что действительное число не изменяется, а системы счисления просто по-разному его выражают.

Вопрос, какое число записано в строке "11" покажется странным, ведь для большинства очевидно, что это одиннадцать.

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

• Двоичная: с основой 2;
• Восьмеричная: с основой 8;
• Шестнадцатеричная (hex): с основой 16.

Что же мы подразумеваем, говоря что определённая система счисления имеет основу N?

Один из способов объяснения разных систем счисления заключается в том, чтобы представить, что у вас N пальцев.

Если же вам требуется более подробное объяснение систем счисления, обратитесь к книге Чарльза Петцольда «Код». В этой книге детально объясняются основы работы вычислительной техники.

Конструктор int() — один из способов показать, как разные системы счисления преобразуют одну и ту же строку с помощью Python. Если вы передадите str в int(), Python по умолчанию будет считать, что строка содержит число в десятичной системе. Однако вы можете дать другие указания:

>>> int('11')
11
>>> int('11', base=10)  # 10 установлено по умолчанию
11
>>> int('11', base=2)  # Двоичная
3
>>> int('11', base=8)  # Восьмеричная
9
>>> int('11', base=16)  # Шестнадцатеричная
17

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

Всё это — разновидности целочисленных литералов. Результаты применения префиксов будут такими же, как и в случае использования int() с определением параметра base. Для Python всё это просто целые числа:

>>> 11
11
>>> 0b11  # Двоичный литерал
3
>>> 0o11  # Восьмеричный литерал
9
>>> 0x11  # Шестнадцатеричный литерал
17

В таблице ниже отражено, как можно ввести десятичные числа от 0 до 20 в двоичном, восьмеричном и шестнадцатеричном эквиваленте. Любой из этих способов можно использовать как в оболочке интерпретатора Python, так и в исходном коде, и все эти числа будут рассматриваться как относящиеся к типу int.

Кстати, вы можете сами убедиться, что подобные способы записи чисел очень часто используется в Стандартной Библиотеке Python. Найдите папку lib/python3.7/ в своей системе, перейдите в неё и введите команду:

$ grep -nri --include "*\.py" -e "\b0x" lib/python3.7

Команда сработает в любой Unix-системе с утилитой grep. С её помощью вы найдёте все шестнадцатеричные литералы. Для поиска двоичных используйте \b0b, а для восьмеричных — \b0o.

Для чего же нужны альтернативные литералы целых чисел? Если коротко, числа 2, 8 и 16, в отличие от 10, являются степенями двойки. Основанные на них системы счисления выражают численные значения способами, более удобными для обработки бинарными вычислительными устройствами. К примеру, 65536, или 2¹⁶, в шестнадцатеричной системе просто 10000 или, используя литерал, 0x10000.

Введение в Юникод

Как видите, проблема ASCII в том, что этой таблицы недостаточно для отображения знаков, символов и глифов, использующихся во всех языках и диалектах мира. Её недостаточно даже для английского языка.

Юникод служит тем же целям, что и ASCII, но содержит намного больший набор кодовых точек. В период времени между появлением ASCII и принятием Юникода использовалось ещё несколько различных кодировок, но рассматривать их подробно нет смысла, так как Юникод и одна из его схем, UTF-8, в настоящее время стали использоваться практически повсеместно.

Вы можете представить Юникод как расширенную версию ASCII-таблицы — с 1 114 112 возможными кодовыми точками, от 0 до 1 114 111. Это 17*(2¹⁶) или 0x10ffff в шестнадцатеричном представлении. Фактически, ASCII является частью Юникода, так как первые 128 символов этих кодировок полностью совпадают.

Чтобы соблюсти технические детали, сам по себе Юникод не является кодировкой. Он скорее реализуется в различных кодировках символов, как вы вскоре увидите. По структуре Юникод скорее ассоциативный массив (что-то вроде dict) или база данных, состоящая из таблицы с двумя колонками. В этой таблице разные символы (такие как "a", "¢", или даже "ቈ") соотносятся с различными целыми положительными числами. Кодировка же должна предоставлять несколько больше возможностей.

Юникод содержит практически любой символ, который только можно представить, включая дополнительные непечатаемые. Например, кодовая точка 8207 соответствует отметке RTL, которая используется для смены направления письма. Она полезна в текстах, где абзацы на одном из европейских языков соседствуют с абзацами на арабских языках.

Прим. Кстати, если уж мы хотим быть совсем точны в деталях, то надо отметить ещё один факт. Исторически сложилось, что в Юникоде доступны только 1 111 998 кодовых точек.

Юникод и UTF-8

Довольно скоро стало понятно, что все необходимые символы невозможно вместить в таблицу, используя только один байт. Современные, более ёмкие кодировки требовали использования больших объёмов.

Ранее мы упоминали, что Юникод сам по себе не является кодировкой. И вот почему.

Юникод не содержит указаний по извлечению из текста бит, он работает только с кодовыми точками. В нём нет стандарта конверсии текста в двоичные данные и обратно.

Юникод является абстрактным стандартом кодировки. Для практического его применения чаще всего используют схему UTF-8. Стандарт Юникод (таблица соответствий символов кодовыми точкам) определяет несколько различных кодировок на основе единого набора символов.

Как и менее распространённые UTF-16 и UTF-32, UTF-8 — формат кодировки для отображения символов Юникода в двоичном виде, используя один или несколько байт на один символ. UTF-16 и UTF-32 мы обсудим чуть позже, но пока нам интересен UTF-8 как самый популярный формат.

Сначала требуется разобрать термины «‎‎кодирование»‎ и «‎декодирование»‎.

Кодирование и декодирование в Python 3

Тип данных str в Python 3 рассчитан на представление текста в удобном для чтения формате и может содержать любые символы Юникода.

Тип bytes, напротив, представляет двоичные данные, последовательность байт, без указания на кодировку.

Кодирование и декодирование — это процесс перехода данных из одной формы в другую.

В методах .encode() и .decode() по умолчанию используется параметр "utf-8", однако для большей уверенности этот параметр можно определить самостоятельно:

>>> "résumé".encode("utf-8")
b'r\xc3\xa9sum\xc3\xa9'
>>> "El Niño".encode("utf-8")
b'El Ni\xc3\xb1o'

>>> b"r\xc3\xa9sum\xc3\xa9".decode("utf-8")
'résumé'
>>> b"El Ni\xc3\xb1o".decode("utf-8")
'El Niño'

str.encode() возвращает объект типа bytes. И литералы этого типа объектов (такие как b"r\xc3\xa9sum\xc3\xa9"), и его отображение допускают только символы ASCII.

Вот почему при вызове "El Niño".encode("utf-8"), ASCII-совместимое "El" отображается как есть, а n с тильдой экранируется в "\xc3\xb1". Этой с виду неудобочитаемой последовательностью представлены два байта, 0xc3 и 0xb1 в шестнадцатеричной системе:

>>> " ". join(f"{i:08b}" for i in (0xc3, 0xb1))
'11000011 10110001'

Таким образом символ ñ требует два байта для бинарного представления с помощью UTF-8.

Прим. Если вы введёте help(str.encode), скорее всего, увидите параметр по умолчанию encoding='utf-8'. Однако имейте в виду, что настройки Windows для Python 3.6 могут отличаться, поэтому использовать методы кодирования и декодирования без указания необходимой кодировки (например "résumé".encode()) следует с осторожностью.

Python 3: всё на Юникоде

Python 3 полностью реализован на Юникоде, а точнее на UTF-8. Вот что это означает:

• По умолчанию предполагается, что исходный код Python 3 написан с помощью UTF-8. Это значит, что вам не нужно использовать определение # -*- coding: UTF-8 -*- в начале файлов .py в этой версии языка.
• Все тексты (объекты формата str) реализованы на Юникоде. Кодированный текст представлен двоичными данными (bytes). Тип strможет содержать любой символ-литерал из Юникода (например "Δv / Δt"), и все они хранятся в Юникоде.
• Любой из символов Юникода приемлем в качестве идентификатора. Например, вы можете использовать выражение résumé = "~/Documents/resume.pdf".
• В модуле re по умолчанию установлен флаг re.UNICODE, а не re.ASCII. Это означает, что r"\w" соответствует буквам из Юникода, а не просто символам ASCII.
• По умолчаниюencoding в str.encode() в bytes.decode() установлен в UTF-8.

Нужно отметить также нюанс, касающийся встроенного метода open(). Его параметр encoding зависит от платформы и определяется значением locale.getpreferredencoding():

>>> # Mac OS X High Sierra
>>> import locale
>>> locale.getpreferredencoding()
'UTF-8'

>>> # Windows Server 2012; другие сборки Windows могут использовать UTF-16
>>> import locale
>>> locale. getpreferredencoding()
'cp1252'

Мы делаем упор на эти моменты, чтобы вы вдруг не подумали, что кодировка UTF-8 является универсальной. Она действительно широко распространена, но вы вполне можете столкнуться и с другими вариантами. Не будет лишним предусмотреть это в коде.

Один байт, два байта, три байта, четыре…

Одна из важнейших особенностей UTF-8 состоит в том, что это кодировка с переменным размером.

Вспомните раздел, посвящённый ASCII. Любой символ в этой таблице требует максимум одного байта пространства. Это можно быстро проверить с помощью следующего генератора:

>>> all(len(chr(i).encode("ascii")) == 1 for i in range(128))
True

С UTF-8 дела обстоят по-другому. Символы Юникода могут занимать от одного до четырёх байт. Вот пример четырёхбайтного символа:

>>> ibrow = "🤨"
>>> len(ibrow)
1
>>> ibrow.encode("utf-8")
b'\xf0\x9f\xa4\xa8'
>>> len(ibrow. encode("utf-8"))
4

>>> # Вызов list() с объектом типа bytes возвращает
>>> # значение каждого байта
>>> list(b'\xf0\x9f\xa4\xa8')
[240, 159, 164, 168]

Это небольшая, но важная особенность метода len():

• Размер единичного символа Юникода в объекте str языка Python всегда будет равен 1, вне зависимости от количества занимаемых байт.
• Длина того же символа в объекте типа bytes будет варьироваться от 1 до 4.

Таблица ниже показывает, сколько байт занимают основные типы символов.

_{*Такие как английский, арабский, греческий, ирландский.
**Масса языков и символов, в основном китайский, японский и корейский с разделением по томам (а также ASCII и латиница).
***Дополнительные символы китайского, японского, корейского и вьетнамского, а также другие символы и эмоджи.}

Прим. У UTF-8 есть и другие технические особенности. Те, кто работает на Python, редко с ними сталкиваются, поэтому мы не будем раскрывать их в этой статье, но упомянем вкратце, чтобы сохранить полноту картины. Так, UTF-8 использует коды-префиксы, указывающие на количество байт в последовательности. Такой приём позволяет декодеру группировать байты в условиях кодировки с переменным размером. Количество байт в последовательности определяется первым её байтом. Другие технические подробности можно найти на странице Википедии, посвящённой UTF-8 или на официальном сайте.

Особенности UTF-16 и UTF-32

Рассмотрим альтернативные кодировки, UTF-16 и UTF-32. Различие между ними и UTF-8 в основном практическое. Продемонстрируем величину расхождения с помощью перевода туда и обратно:

>>> letters = "αβγδ"
>>> rawdata = letters. encode("utf-8")
>>> rawdata.decode("utf-8")
'αβγδ'
>>> rawdata.decode("utf-16")  # 😧
'뇎닎돎듎'

В данном случае, когда мы кодируем четыре буквы греческого алфавита в двоичные данные с помощью UTF-8, а декодируем обратно в текст с использованием UTF-16, на выходе получается строка с совершенно другими символами (из корейского алфавита).

Так происходит, если для кодирования и декодирования применяют разные кодировки. Два варианта декодирования одного бинарного объекта могут вернуть текст даже на другом языке.

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

Любопытный аспект семейства UTF: UTF-8 не всегда занимает меньше памяти, чем UTF-16. Хотя с точки зрения математики это выглядит маловероятным, однако это возможно:

>>> text = "記者 鄭啟源 羅智堅"
>>> len(text.encode("utf-8"))
26
>>> len(text.encode("utf-16"))
22

Так получается из-за того, что кодовые точки в диапазоне от U+0800 до U+FFFF (от 2048 до 65535 в десятичной системе) в кодировке UTF-8 занимают три байта, а в UTF-16 только два.

Это не означает, что нужно работать с UTF-16, независимо от того, насколько часто вы работаете с символами в этом диапазоне. Один из самых важных поводов придерживаться UTF-8 — в мире кодировок лучше держаться вместе с большинством.

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

Прим. перев. Есть и более весомые причины использовать UTF-8. Среди них её обратная совместимость с ASCII, а также то, что это самосинхронизирующаяся кодировка.

Python и встроенные функции

Вы освоили самую сложную часть статьи. Теперь посмотрим, как всё изученное реализуется на Python.

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

Логически их можно сгруппировать по назначению.

• ascii(), bin(), hex() и oct() предназначены для различного представления вводных данных. Все они возвращают str. Первая, ascii(), производит представление объекта в ASCII, экранируя не входящие в эту таблицу символы. Оставшиеся три дают соответственно двоичное, шестнадцатеричное и восьмеричное представление целого числа. Все эти функции меняют только представление объекта, не изменяя непосредственно вводные данные.
• bytes(), str() и int() — конструкторы классов соответствующих типов: bytes, str, и int. Все они предлагают способы подогнать данные под желаемый тип.
• ord() и chr() выполняют противоположные действия. ord() конвертирует символ в десятичную кодовую точку, а chr() принимает в качестве аргумента целое число, и возвращает символ, кодовой точкой которого это число является.

В таблице ниже эти функции разобраны более подробно:

Дальше можно посмотреть полезные примеры использования этих функций.

ascii():

>>> ascii("abcdefg")
"'abcdefg'"

>>> ascii("jalepeño")
"'jalepe\\xf1o'"

>>> ascii((1, 2, 3))
'(1, 2, 3)'

>>> ascii(0xc0ffee)  # Шестнадцатеричный литерал (int)
'12648430'

bin():

>>> bin(0)
'0b0'

>>> bin(400)
'0b110010000'

>>> bin(0xc0ffee)  # Шестнадцатеричный литерал (int)
'0b110000001111111111101110'

>>> [bin(i) for i in [1, 2, 4, 8, 16]]  # `int` + обработка списка
['0b1', '0b10', '0b100', '0b1000', '0b10000']

bytes():

>>> # Последовательность целых чисел
>>> bytes((104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100))
b'hello world'

>>> bytes(range(97, 123))  # Последовательность целых чисел
b'abcdefghijklmnopqrstuvwxyz'

>>> bytes("real 🐍", "utf-8")  # Строка + кодировка
b'real \xf0\x9f\x90\x8d'

>>> bytes(10)
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'

>>> bytes. fromhex('c0 ff ee')
b'\xc0\xff\xee'

>>> bytes.fromhex("72 65 61 6c 70 79 74 68 6f 6e")
b'realpython'

chr():

>>> chr(97)
'a'

>>> chr(7048)
'ᮈ'

>>> chr(1114111)
'\U0010ffff'

>>> chr(0x10FFFF)  # Шестнадцатеричный литерал (int)
'\U0010ffff'

>>> chr(0b01100100)  # Двоичный литерал (int)
'd'

hex():

>>> hex(100)
'0x64'

>>> [hex(i) for i in [1, 2, 4, 8, 16]]
['0x1', '0x2', '0x4', '0x8', '0x10']

>>> [hex(i) for i in range(16)]
['0x0', '0x1', '0x2', '0x3', '0x4', '0x5', '0x6', '0x7',
 '0x8', '0x9', '0xa', '0xb', '0xc', '0xd', '0xe', '0xf']

int():

>>> int(11.0)
11

>>> int('11')
11

>>> int('11', base=2)
3

>>> int('11', base=8)
9

>>> int('11', base=16)
17

>>> int(0xc0ffee - 1. 0)
12648429

>>> int.from_bytes(b"\x0f", "little")
15

>>> int.from_bytes(b'\xc0\xff\xee', "big")
12648430

oct():

>>> ord("a")
97

>>> ord("ę")
281

>>> ord("ᮈ")
7048

>>> [ord(i) for i in "hello world"]
[104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]

str():

>>> str("str of string")
'str of string'

>>> str(5)
'5'

>>> str([1, 2, 3, 4])  # Like [1, 2, 3, 4].__str__(), but use str()
'[1, 2, 3, 4]'

>>> str(b"\xc2\xbc cup of flour", "utf-8")
'¼ cup of flour'

>>> str(0xc0ffee)
'12648430'

Литералы для строк на Python

Вместо использования конструктора str(), объект этого типа чаще вводят напрямую:

>>> meal = "shrimp and grits"

Выглядит достаточно просто. Но есть один аспект, о котором нужно помнить. Поскольку Python позволяет использовать все возможности Юникода, можно «напечатать» символы, которых вы никогда не найдёте на клавиатуре. Можно скопировать и вставить их прямо в оболочку интерпретатора:

>>> alphabet = 'αβγδεζηθικλμνξοπρςστυφχψ'
>>> print(alphabet)
αβγδεζηθικλμνξοπρςστυφχψ

Кроме ввода через консоль реальных, неэкранированых символов Юникода, существуют и другие способы ввода текстовых строк.

Самые насыщенные разделы документации Python посвящены лексическому анализу. В частности, раздел о строках и литералах. Возможно, для понимания данного аспекта языка этот раздел придётся неоднократно перечитать.

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

Первый, и самый распространённый метод, как вы уже видели — прямой ввод. Проблема состоит в поиске необходимых сочетаний клавиш. Здесь и могут пригодиться другие способы получения и представления символов. Вот полный список:

Это соответствие можно проверить на практике:

>>> (
. ..     "a" ==
...     "\x61" == 
...     "\N{LATIN SMALL LETTER A}" ==
...     "\u0061" ==
...     "\U00000061"
... )
True

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

1. Не каждый способ работает со всеми символами. Шестнадцатеричное представление числа 300 выглядит как 0x012c, а это значение просто не поместится в экранирующий код "\xhh", так как в нём допускаются всего две цифры. Самая большая кодовая точка, которую можно втиснуть в этот формат — "\xff" ("ÿ"). Аналогичо "\ooo" можно использовать только до "\777" ("ǿ").
2. Для \xhh, \uxxxx, и \Uxxxxxxxx требуется вводить ровно столько цифр, сколько указано в примерах. Это может стать неприятным сюрпризом, поскольку обычно основанные на Юникоде таблицы содержат кодовые точки для символов с префиксом U+ и варьирующимся количеством шестнадцатеричных символов. В этих таблицах кодовые точки отображают только значимые цифры.

Например, если вы обратитесь к сайту unicode-table.com с целью получить данные готического символа faihu (или fehu), "𐍆", его кодовая точка будет U+10346.

Как же можно разместить его в "\uxxxx" или "\Uxxxxxxxx"? В "\uxxxx" эту кодовую точку вместить невозможно, поскольку она соответствует четырёхбайтному символу. А чтобы представить его в "\Uxxxxxxxx", придётся выровнять последовательность с левой стороны:

>>> "\U00010346"
'𐍆'

Это также значит, что экранирующая последовательность "\Uxxxxxxxx" — единственная последовательность, способная вместить любой символ Юникода.

Прим. Вот код небольшой, но удобной функции, переводящей записи типа "U+10346" в приемлемый для Python формат с помощью str.zfill():

>>> def make_uchr(code: str):
. ..     return chr(int(code.lstrip("U+").zfill(8), 16))
>>> make_uchr("U+10346")
'𐍆'
>>> make_uchr("U+0026")
'&'

Другие поддерживаемые Python кодировки

Пока что мы рассказали про 4 разные кодировки символов:

1. ASCII;
2. UTF-8;
3. UTF-16;
4. UTF-32.

Однако существует большое количество и других вариантов кодировки.

Один из примеров — Latin-1 (другое название ISO-8859-1). Это базовая кодировка для Hypertext Transfer Protocol (HTTP) в спецификации RFC 2616. Для Windows существует собственный вариант Latin-1, который называется cp1252.

Прим. Кодировка ISO-8859-1 всё ещё широко используется. Библиотека requests неукоснительно придерживается спецификации RFC 2616, используя её по умолчанию для содержимого отзывов HTTP/HTTPS. Если в заголовке Content-Type находится слово «text» и не выбрана другая кодировка, requests использует ISO-8859-1.

Полный список допустимых кодировок можно найти в документации модуля codecs, входящего в набор стандартных библиотек Python.

Среди этих кодировок стоит упомянуть ещё одну, зачастую весьма полезную. Это "unicode-escape". Если вы декодировали str и хотите быстро получить представление содержащихся в ней экранированных литералов Юникода, можно определить эту кодировку в .encode:

>>> alef = chr(1575)  # Или "\u0627"
>>> alef_hamza = chr(1571)  # Или "\u0623"
>>> alef, alef_hamza
('ا', 'أ')
>>> alef.encode("unicode-escape")
b'\\u0627'
>>> alef_hamza.encode("unicode-escape")
b'\\u0623'

Вы знаете, что говорят насчёт предположений…

Хотя Python по умолчанию предполагает, что файлы и код созданы на основе кодировки UTF-8, вам, как программисту, не следует делать аналогичное предположение относительно сторонних данных.

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

Все операции ввода-вывода осуществляют в байтах, наборе нулей и единиц, пока вы не сообщите системе кодировку для преобразования этих данных в текст.

Приведём пример того, что может пойти не так. Допустим, вы подписаны на API, который передаёт вам рецепт блюда дня. Вы получаете его в формате bytes и раньше всегда без проблем декодировали с использованием .decode("utf-8") . Но именно в этот день часть рецепта выглядела так:

>>> data = b"\xbc cup of flour"

Похоже, нам потребуется мука, но сколько?

>>> data.decode("utf-8")
Traceback (most recent call last):
  File "", line 1, in 
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xbc in position 0: invalid start byte

А вот и та самая неприятная ошибка UnicodeDecodeError. Подобное вполне может произойти, когда вы делаете предположение об используемой кодировке. Уточняем у разработчика ресурса, предоставляющего API. Выясняется, что полученный вами файл был закодирован с помощью  Latin-1:

>>> data.decode("latin-1")
'¼ cup of flour'

Именно в этом и крылась проблема. В Latin-1 каждый символ кодируется одним байтом, в вот в UTF-8 символ «¼» требует два байта ("\xc2\xbc").

Как видите, делать предположения относительно кодировки полученных данных довольно рискованно. Обычно это UTF-8, однако в тех случаях, когда это не так, у вас могут возникнуть проблемы.

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

Всякая всячина: unicodedata

Нельзя не упомянуть также модуль unicodedata. Он позволяет взаимодействовать с базой данных символов Юникода (Unicode Character Database, UCD).

>>> import unicodedata

>>> unicodedata.name("€")
'EURO SIGN'
>>> unicodedata.lookup("EURO SIGN")
'€'

Подводим итоги

Итак, в этой статье вы познакомились со следующими концепциями кодировки символов в Python:

• Фундаментальные принципы кодировки символов и систем счисления;
• Целочисленные, двоичные, восьмеричные, шестнадцатеричные, строковые и байтовые литералы в Python;
• Встроенные функции языка, работающие с кодировкой и системами счисления;
• Особенности обработки текстовых и двоичных данных.

Дополнительные источники

Ещё больше информации можно получить из следующих материалов (на английском языке):

• UTF-8 Everywhere Manifesto.
• Joel Spolsky: Минимальный уровень знаний о Юникоде и наборах символов, требующийся каждому разработчику ПО (Без отговорок!).  
• David Zentgraf: Что обязательно должен знать о кодировках и наборах символов каждый программист для работы с текстом. 
• Mozilla: Комплексный подход к определению языков и кодировок.
• Wikipedia.
• John Skeet: Юникод и .NET.
• Network Working Group, RFC 3629: UTF-8, формат преобразования ISO 10646.
• Unicode Technical Standard #18: Регулярные выражения Юникода.

В документации языка нашему вопросу посвящены два раздела:

Перевод статьи Unicode & Character Encodings in Python: A Painless Guide

Значение ASCII символа в Python Ru Python

Отсюда :

функция ord () получит значение int char. И если вы хотите конвертировать обратно после игры с номером, функция chr () делает трюк.

>>> ord('a') 97 >>> chr(97) 'a' >>> chr(ord('a') + 3) 'd' >>> 

В Python 2 существует также функция unichr , возвращающая символ Unicode , порядковый номер которого является аргументом unichr :

 >>> unichr(97) u'a' >>> unichr(1234) u'\u04d2' 

В Python 3 вы можете использовать chr вместо unichr .

Обратите внимание, что ord () не дает вам значение ASCII как таковое; он дает вам числовое значение символа в любой кодировке, в которой он находится. Поэтому результат ord (‘ä’) может быть 228, если вы используете Latin-1, или он может поднять TypeError, если вы используете UTF- 8. Он может даже вернуть код Unicode вместо этого, если вы передадите ему unicode:

 >>> ord(u'あ') 12354 

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

 for ch in mystr: code = ord(cd) 

или немного быстрее:

 for code in map(ord, mystr): 

вы конвертируете в родные типы Python, которые непосредственно перебирают коды. На Python 3 это тривиально:

 for code in mystr.encode('ascii'): 

и на Python 2.6 / 2. 7 это лишь немного больше, потому что у него нет байтового bytes типа Py3 ( bytes – это псевдоним для str , который итерации по символу), но у них есть bytearray :

 # If mystr is definitely str, not unicode for code in bytearray(mystr): # If mystr could be either str or unicode for code in bytearray(mystr, 'ascii'): 

Кодирование как тип, который изначально повторяется по порядку, означает, что преобразование идет намного быстрее; в локальных тестах как на Py2.7, так и на Py3.5, итерация str для получения кодов ASCII с использованием map(ord, mystr) начинается примерно вдвое длиннее для len 10 str чем использование bytearray(mystr) на Py2 или mystr.encode('ascii') на Py3, а по мере того как str получает больше, множитель, заплаченный за map(ord, mystr) увеличивается до ~ 6.5x-7x.

Единственный недостаток заключается в том, что преобразование происходит сразу, поэтому ваш первый результат может занять немного больше времени, и поистине огромная str будет иметь пропорционально большие временные bytes / bytearray , но если это не приведет вас к bytearray страницы, это не вероятно, имеет значение.

python: расширенные коды ASCII — CodeRoad

Привет, я хочу знать, как я могу добавить, а затем распечатать расширенные коды ASCII в python.
У меня есть следующее.

code = chr(247)

li = []
li.append(code)
print li

Результат python выводится на печать [‘\xf7’], когда он должен быть символом деления. Если я просто напечатаю код непосредственно «print code», то получу символ деления, но не добавлю его в список. Что я делаю не так?

Спасибо.

python

ascii

python-2.x

Поделиться

Источник

user1831677    

21 января 2014 в 09:22

4 ответа

• Расширенные Ascii символов в Code::Blocks C++

  Я пытаюсь использовать расширенные коды Ascii в консольном приложении, используя C++ и Code::Blocks (коды символов больше 128). http:/ / www.asciitable.com / консоль показывает знак вопроса внутри алмаза. Я пытался до сих пор: char myChar = 200; cout << myChar; cout <<…

• Как узнать, какие столбцы и строки содержат расширенные коды ASCII?

  Может ли кто-нибудь помочь, как узнать,какие столбцы и строки имеют расширенные коды ASCII в таблице (EX:-Ž,™, Ù)? Примеры jacob\Û =дружище® Мне нужно запросить что-то вроде Select * from table, чтобы получить Extended ASCII Спасибо за помощь

11

Когда вы печатаете список, он выводит представление по умолчанию всех его элементов-то есть вызывая repr() для каждого из них. repr() строки-это ее экранированный код, по замыслу. Если вы хотите правильно вывести все элементы списка, вам следует преобразовать его в строку, например через ', '.join(li) .

Обратите внимание, что, как было сказано в комментариях, на самом деле нет такой вещи, как «extended ASCII», есть просто различные различные кодировки.

Поделиться

Daniel Roseman    

21 января 2014 в 09:32

9

Нет такой вещи, как «extend ASCII Codes» — есть, однако, множество символов, десятки тысяч, как определено в стандартах Unicode.

Вы можете ограничиться кодировкой кодировки вашего текста terminal, который вы можете считать «Extend ASCII»,, но который может быть, например, «latin-1», (если вы находитесь в системе Unix, такой как Linux или Mac OS X, ваш текст terminal, скорее всего, будет использовать кодировку UTF-8 и сможет отображать любой из десятков тысяч символов, доступных в Unicode)

Итак, вы должны прочитать эту статью, чтобы понять, что такое текст после 1992 года —
Если вы попытаетесь сделать какое-либо производственное приложение, веря в «extended ASCII», вы навредите себе, своим пользователям и всей экосистеме сразу: http://www.joelonsoftware. com/articles/Unicode. html

Тем не менее, Python2 (и Python3) print вызовет неявное преобразование str для передаваемых объектов. Если вы используете список, это преобразование не рекурсивно вызывает str для каждого элемента списка, вместо этого оно использует repr элемента, который отображает символы, отличные от ASCII, в качестве их числового представления или других неподходящих обозначений.

Вы можете просто соединить нужные символы в строку unicode, например, а затем распечатать их обычным способом, используя кодировку terminal:

import sys

mytext = u""
mytext += unichr(247) #check the codes for unicode chars here:  http://en.wikipedia.org/wiki/List_of_Unicode_characters

print mytext.encode(sys.stdout.encoding, errors="replace")

Поделиться

jsbueno    

21 января 2014 в 09:42

5

Вы, вероятно, хотите, кодирование с набором символов, которая позволяет включить Юникод в байты без ‘magic’ преобразования.

s='\xf7'
b=s.encode('charmap')
with open('/dev/stdout','wb') as f:
    f.write(b)
    f.flush()

Напечатает ÷ в моей системе.

Обратите внимание, что ‘extended ASCII’ относится к любому из ряда проприетарных расширений ASCII, ни одно из которых никогда не было официально принято и все они несовместимы друг с другом. В результате символ, выводимый этим кодом, будет варьироваться в зависимости от выбора управляющим terminal способа его интерпретации.

Поделиться

Perkins    

12 февраля 2016 в 00:39

• PHP-строка только с ASCII-расширенными символами

  С PHP я хотел бы знать, содержит ли мой $string какие-либо не ASCII-расширенные символы от 33 до 255 из этого списка: http://www.ascii-code.com / Кроме того, можно ли включить другие сортированные символы ASCII для отклонения? Например, 182 и 135 (символы¶ и ‡ соответственно). Я имею в виду, что…

• узел JS консольный журнал ascii символ

  Привет Я использую узел JS для своего приложения, и я хочу напечатать ascii символов в terminal. Вот таблица для ascii символов. Пожалуйста, проверьте поле расширенные коды ASCII. Я хочу напечатать квадрат или круг, например 178 или 219. Может ли кто-нибудь сказать мне, как я могу это сделать?…

1

Вы не делаете ничего плохого.

Что вы делаете, так это добавляете строку длиной 1 в список.

Эта строка содержит символ за пределами диапазона печатаемых символов и за пределами ASCII (который составляет всего 7 бит). Вот почему его представление выглядит как '\xf7' .

Если вы напечатаете его, он будет преобразован так хорошо, как только может система.

В Python 2 байт будет просто напечатан. Результирующим результатом может быть символ деления или любая другая вещь, в зависимости от того, что кодирует ваша система.

В Python 3 это символ Юникода, который будет обрабатываться в соответствии с настройкой stdout . Обычно это действительно должен быть символ деления.

В представлении списка вызывается __repr__() строки, что приводит к тому, что вы видите.

Поделиться

glglgl    

21 января 2014 в 09:49

Похожие вопросы:

Могу ли я использовать iconv для преобразования многобайтовых смарт-кавычек в расширенные смарт-кавычки ASCII?

У меня есть некоторый контент UTF-8, который включает в себя многобайтовые умные символы кавычек. Я обнаружил, что этот код легко преобразует эти символы в ASCII прямые кавычки (ASCII код 34):…

Как преобразовать расширенные имена сущностей ASCII в HTML в Python?

В настоящее время я делаю это, чтобы заменить расширенные символы-ascii их эквивалентами HTML-entity-number: s. encode(‘ascii’, ‘xmlcharrefreplace’) То, что я хотел бы сделать, это преобразовать в…

использование расширенных кодов Ascii с Python

Я создал словарь с Python, но у меня есть проблемы с расширенными кодами Ascii. Цикл, который создает словарь, таков: (ascii число 128-164 : é, à и т. д.) #extented ascii codes i = 128 while i <=…

Расширенные Ascii символов в Code::Blocks C++

Я пытаюсь использовать расширенные коды Ascii в консольном приложении, используя C++ и Code::Blocks (коды символов больше 128). http:/ / www.asciitable.com / консоль показывает знак вопроса внутри…

Как узнать, какие столбцы и строки содержат расширенные коды ASCII?

Может ли кто-нибудь помочь, как узнать,какие столбцы и строки имеют расширенные коды ASCII в таблице (EX:-Ž,™, Ù)? Примеры jacob\Û =дружище® Мне нужно запросить что-то вроде Select * from table,…

PHP-строка только с ASCII-расширенными символами

С PHP я хотел бы знать, содержит ли мой $string какие-либо не ASCII-расширенные символы от 33 до 255 из этого списка: http://www. ascii-code.com / Кроме того, можно ли включить другие сортированные…

узел JS консольный журнал ascii символ

Привет Я использую узел JS для своего приложения, и я хочу напечатать ascii символов в terminal. Вот таблица для ascii символов. Пожалуйста, проверьте поле расширенные коды ASCII. Я хочу напечатать…

Как визуализировать расширенные символы ASCII в terminal с помощью nodejs

Согласно этому сайту , ASCII расширенные коды символов 176, 177 и 178 соответствуют трем символам, состоящим из прямоугольников разных оттенков: Вот более подробно, символ 178: Теперь, согласно…

Как показать » ± » в python?

Просто примерный вопрос. Можно ли показать символ ± в Python? Я просто попытался использовать расширенные коды ASCII char(241) , но это не сработало. Простой код: b = chr(241) #The Extended ASCII…

Как правильно печатать расширенные символы ASCII с помощью json.dumps() — Python

У меня есть этот файл JSON с некоторыми символами, которые принадлежат Extended ASCII characters , например », •, ñ, Ó, Ä { @index: 1, row: [ { col: [ { text: { @x: 1, #text: Text » 1 A\\CÓ } } ] },. ..

Transliterating non-ASCII characters with Python

Contents

Lesson Goals

This lesson shows how to use Python to transliterate automatically a
list of words from a language with a non-Latin alphabet to a
standardized format using the American Standard Code for Information
Interchange (ASCII) characters. It builds on readers’ understanding
of Python from the lessons “Viewing HTML Files,” “Working with Web
Pages,” “From HTML to List of Words (part 1)” and “Intro to
Beautiful Soup.” At the end of the lesson, we will use the
transliteration dictionary to convert the names from a database of the
Russian organization Memorial from Cyrillic into Latin
characters. Although the example uses Cyrillic characters, the
technique can be reproduced with other alphabets using Unicode.

What Is Transliteration and for Whom Is It Useful?

Transliteration is something that most people do every day, knowingly or
not. Many English speakers would have trouble recognizing the name
Владимир Путин but know that Vladimir Putin is Russia’s current
president. Transliteration is especially useful with names, because a
standardized transliterated name is often the same as a translated name.
(Exceptions are when someone’s name is translated in a non-uniform way.
Leon Trotsky’s Russian name would be transliterated in a standardized
form as Lev Trotskii.)

But transliteration has other uses too, especially for scholars. In many
fields, the publishing convention is to transliterate any evidence used
in the original. Moreover, citations from scholarly works need to be
transliterated carefully so that readers can find and verify evidence
used in texts. Finally, transliteration can be more practical for
authors who can type more fluently with Latin letters than in the native
alphabet of a language that does not use Latin characters.

This lesson will be particularly useful for research in fields that use
a standardized transliteration format, such as Russian history field,
where the convention is to use a simplified version of the American
Library Association-Library of Congress (ALA-LC) transliteration
table. (All tables currently available can be accessed here.)
Researchers dealing with large databases of names can benefit
considerably. However, this lesson will also allow practice with
Unicode, character translation and using the parser Beautiful Soup in
Python.

Converting a Webpage to Unicode

The goal of this lesson is to take a list of names from a Russian
database and convert them from Cyrillic into ASCII characters. The page
we will use is from the site of the Russian human rights organization
Memorial. During Glasnost professional and amateur historians in the
Soviet Union gained the ability to conduct research on previously taboo
subjects, such as repression under Stalin. Banding together, they
founded Memorial to collect and publicize their findings. Today, the
NGO conducts research on a range of civil rights abuses in Russia, but
collecting data about the victims of Stalinism remains one of its main
functions. On the Memorial website researchers can find a database with
some three million entries of people who were arrested or executed by
Stalin’s regime. It is an important resource on a dark topic. However,
because the database has many, many names, it lends itself nicely to
automated transliteration. This lesson will use just the first page of
the database, found here, but using the lesson on “Automated
Downloading with Wget,” it would be possible to go through the entire
database as fast as your computer would allow.

We need to start by modifying the process found in the lesson “Working
with Web Pages.” There we learned how to open and copy the HTML from
a web page in Python. But what if we want to open a page in a language
that does not use Latin characters? Python can do this but we need to
tell it how to read these letters using a codec, a library of codes that
allows Python to represent non-ASCII characters. Working with web pages
makes this easy because almost all web pages specify what kind of
encoding they use, in the page’s headers. In Python, opening a web page
does not just give you the HTML, but it creates an object with several
useful characteristics. One is that we can access the headers by calling
the header() method. This method returns something a lot like a Python
dictionary with information that is important to web programmers. For
our purposes, what is important is that the encoding is stored under the
‘content-type’ key.

#transliterator.py
from urllib.request import urlopen

page = urlopen('http://lists.memo.ru/d1/f1.htm')

#what is the encoding?
print(page.headers['content-type'])

Under the ‘content-type’ key we find this information:

text/html; charset=windows-1251

The ‘content-type’ is telling us that the file stored at the url we
accessed is in HTML and that its encoding (after ‘charset=’, meaning
character set) is ‘windows-1251′, a common encoding for Cyrillic
characters. You can visit the webpage and view the Page Source and see
for yourself that the first line does in fact contain a ‘content-type’
variable with the value text/html; charset=windows-1251. It would not be
so hard to work with the ‘windows-1251′ encoding. However,
‘windows-1251′ is specifically for Cyrillic and will not handle all
languages. For the sake of learning a standard method, what we want is
Unicode, a coding set that handles not just Cyrillic but characters and
symbols from virtually any language. (For more on Unicode, see the What
is Unicode page.) Converting into Unicode gives us the potential to
create a transliteration table that could cover multiple languages and
special characters in a way that region-specific character sets do not
allow.

How do you convert the characters to Unicode? First, Python needs to
know the original encoding of the source, ‘windows-1251.’ We could just
assign ‘windows-1251’ to a variable by typing it manually but the
encoding may not always be ‘windows-1251.’ There are other character
sets for Cyrillic, not to mention other languages. Let’s find a way to
make the process more automatic for those cases. It helps that the
encoding is the very last part of the string, so we can isolate it from
everything that came before in the string. By using the .split() method,
the string containing whatever encoding it is can be assigned to a
variable. The .split(separator) method in Python returns a list of
sections in the string that are split by some user-defined separator.
Assigning no separator to .split() separates a string at the spaces.
Another use of the .split() method is to separate by commas, which can
help to work with comma separated value (csv) files. In this case,
though, by splitting the ‘content-type’ string at ‘charset=’, we get a
list with two strings where the second will be the character set.

encoding = page.headers['content-type'].split('charset=')[1]

The encoding is assigned to the variable called ‘encoding’. You can
check to see if this worked by printing the ‘encoding’ variable. Now we
can tell Python how to read the page as Unicode. Using the
str(object [, encoding]) method turns a text encoded in a specific encoding
into a generic Unicode string. A Unicode string cannot only contain ASCII
characters, but also
special characters. If the original text is in a non-ASCII character set,
like here with ‘windows-1251’, we have to use the optional encoding
parameter.

#read the HTML as a string into a variable
content = page.read()

# the unicode method tries to use ASCII so we need to tell it the encoding
content = str(content, encoding)
content[200:300]

'"list-right">\r\n<li><p><a name="n1"></a>А-Аку Туликович </p><p>\r\nРодился\xa0в '

As you can see, the Cyrillic characters are mixed with the ASCII characters
of the HTML code. But typing these can be cumbersome without a corresponding
keyboard layout. Alternatively, the Unicode characters can be typed using
special codes that represent the characters using their Unicode number.
You can see the text as represented by Unicode numbers using the special ‘unicode-escape’ encoding:

# print string using unicode escape sequences
print(content[200:300]. encode('unicode-escape'))

b'"list-right">\\r\\n<li><p><a name="n1"></a>\\u0410-\\u0410\\u043a\\u0443 \\u0422\\u0443\\u043b\\u0438\\u043a\\u043e\\u0432\\u0438\\u0447 </p><p>\\r\\n\\u0420\\u043e\\u0434\\u0438\\u043b\\u0441\\u044f\\xa0\\u0432 '

All the
‘\u0420’-type marks are Unicode and Python knows that they code to
Cyrillic characters. The backslash is called an ‘escape character’
and allows Python to do things like use special characters in Unicode or
signify a line break (‘\n’) in a document. Each counts as just one
character. Now we can create a Python dictionary that will act as the
transliteration table.

Unicode Transliteration Dictionary

A dictionary is an unordered collection of key-object pairs. What this
means is that under each key, the dictionary stores some number or
string or other object – even another dictionary. (See also the lesson
“Counting Frequencies. ”) A dictionary has the following syntax:

my_dictionary = {'Vladimir': 'Putin', 'Boris': 'Yeltsin'}
print(my_dictionary['Vladimir'])

> Putin

How can we turn this into a transliteration table? Just make each
Unicode character a key in the dictionary. Its value will be whatever
character(s) it transliterates to. The table for Romanization of Russian
is available from the Library of Congress. This table needs to be
simplified slightly. The ALA-LC suggests using characters with umlauts
or ligatures to represent Cyrillic letters but those characters are no
more ASCII than Cyrillic characters. So instead no umlauts or ligatures
will be used.

Each Cyrillic letter has a different Unicode value. It would take time
to find each one of them but fortunately Wikipedia has a table. If
the script were very rare, we could find it at the Unicode website.

We just need to combine the transliteration table with the Unicode
table. The Unicode value for the Russian letter “Ж” is 0416 and it
transliterates to the Latin characters “Zh. ” Python needs more than just
the Unicode identifier. It also needs to know to look out for a Unicode
character. Therefore all the Unicode characters used in the dictionary
should be in the format '\uXXXX'. In this case, the letter Ж is
'\u0416'. We can create a transliteration dictionary and assign ‘Zh’
as the value for the key '\u0416' in it.

cyrillic_translit = { '\u0416': 'Zh'}

As it turns out, lowercase Cyrillic letters in Unicode have the same
value as their uppercase counterparts except the value of the second
number is two greater. Thus, ‘ж’ codes to 0436. Now that we have a
transliteration dictionary created, we just add a dictionary key-value
pair.

cyrillic_translit['\u0436'] = 'zh'

Of course, rather than do each pair one by one, it would probably be
easier to write the dictionary in a Python module or paste it in from a
word processor. The full Cyrillic transliteration dictionary is here:

cyrillic_translit={'\u0410': 'A', '\u0430': 'a',
'\u0411': 'B', '\u0431': 'b',
'\u0412': 'V', '\u0432': 'v',
'\u0413': 'G', '\u0433': 'g',
'\u0414': 'D', '\u0434': 'd',
'\u0415': 'E', '\u0435': 'e',
'\u0416': 'Zh', '\u0436': 'zh',
'\u0417': 'Z', '\u0437': 'z',
'\u0418': 'I', '\u0438': 'i',
'\u0419': 'I', '\u0439': 'i',
'\u041a': 'K', '\u043a': 'k',
'\u041b': 'L', '\u043b': 'l',
'\u041c': 'M', '\u043c': 'm',
'\u041d': 'N', '\u043d': 'n',
'\u041e': 'O', '\u043e': 'o',
'\u041f': 'P', '\u043f': 'p',
'\u0420': 'R', '\u0440': 'r',
'\u0421': 'S', '\u0441': 's',
'\u0422': 'T', '\u0442': 't',
'\u0423': 'U', '\u0443': 'u',
'\u0424': 'F', '\u0444': 'f',
'\u0425': 'Kh', '\u0445': 'kh',
'\u0426': 'Ts', '\u0446': 'ts',
'\u0427': 'Ch', '\u0447': 'ch',
'\u0428': 'Sh', '\u0448': 'sh',
'\u0429': 'Shch', '\u0449': 'shch',
'\u042a': '"', '\u044a': '"',
'\u042b': 'Y', '\u044b': 'y',
'\u042c': "'", '\u044c': "'",
'\u042d': 'E', '\u044d': 'e',
'\u042e': 'Iu', '\u044e': 'iu',
'\u042f': 'Ia', '\u044f': 'ia'}

Now that we have the transliteration dictionary, we can simply loop
through every character in the source page and convert those Unicode
characters in the dictionary. If we turn it into a procedure, then we
can reuse it for other webpages.

def transliterate(word, translit_table):
    converted_word = ''
    for char in word:
        transchar = ''
        if char in translit_table:
            transchar = translit_table[char]
        else:
            transchar = char
        converted_word += transchar
    return converted_word

We can then call this function using the newly created dictionary and
the webpage downloaded earlier.

#we will run it with the cyrillic_translit dictionary and the webpage
converted_content = transliterate(content, cyrillic_translit)
converted_content[200:310]

Here is what we end up with:

'="list-right">\r\n<li><p><a name="n1"></a>A-Aku Tulikovich </p><p>\r\nRodilsia\xa0v 1913 g.'

Still not perfect. Python did not convert the special character ‘\xa0′
that signifies a non-breaking space. But with the transliteration
dictionary, any characters that pop up can just be added to the
dictionary and they will be converted. First we need to find out what
that character is. We could search for it on the Internet or we can just
print it:

#let's find out what u'\xa0' is
print('\xa0')

#it's not nothing but a non-breaking space
#it would be better if our transliteration dictionary could change it into a space

cyrillic_translit['\xa0'] = ' '

With this fix, all the Cyrillic and special characters are gone, making
it much easier to read the file and deal with it. For the last part of
the lesson, we will modify methods used in the lesson “Intro to
Beautiful Soup” to get a list of transliterated names from the
webpage.

Transliterated List of Names

There may be cases where it is best to transliterate the entire file but
if the goal is to transliterate and extract just a part of the data in
the file, it would be best to extract first and transliterate later.
That way Python will only transliterate a small part of the file rather
than having to loop through the whole of the HTML. Speed is not a huge
issue when dealing with a handful of web pages but Memorial’s site has
thousands of pages. The difference between looping through thousands of
whole pages and just looping through a small part of each of those pages
can add up. But, of course, it would have been anti-climactic to have
all the names before the transliteration dictionary and also more
difficult for non-Cyrillic readers to understand the rest of the lesson.
So now we need to find a way to get just the names from the page. Here
is the first bit of HTML from the converted_content string, containing
parts of two database entries:

print(converted_content[200:1000])

This code prints out characters 200 to 1000 of the HTML, which happens
to include the entire first entry and the beginning of the second:

="list-right">
<li><p><a name="n1"></a>A-Aku Tulikovich </p><p>
Rodilsia v 1913 g. , Kamchatskaia gub., Tigil'skii r-n, stoibishcha Utkholok; koriak-kochevnik;  malogramotnyi; b/p;

<br />Arestovan  12 noiabria 1938 g.
<br />Prigovoren: Koriakskii okrsud 8 aprelia 1939 g., obv.: po st. 58-2-8-9-10-11 UK RSFSR.
<br />Prigovor: 20 let. Opredeleniem Voennoi kollegii VS SSSR ot 17 oktiabria 1939 g. mera snizhena do 10 let.
Reabilitirovan 15 marta 1958 g. Reabilitirovan opredeleniem Voennoi kollegii VS SSSR
</p><p>Istochnik: Baza dannykh o zhertvakh repressii Kamchatskoi obl.</p></li>
<li><p><a name="n2"></a>Aab Avgust Mikhailovich</p><p>
Rodilsia v 1899 g., Saratovskaia obl., Grimm s.; nemets;  obrazovanie nachal'noe;

Each entry includes lots of information: name (last, first and
patronymic), date of birth, place of birth, profession, date of arrest,
date of sentencing and so on. If we wanted the detailed information
about each person, we would have to parse the page ourselves and extract
that information using the string manipulation techniques from the
lesson “Manipulating Strings in Python. ” However, for just the names
it will be quicker to use the HTML parsing module Beautiful Soup. If you
have not installed Beautiful Soup, see “Installing Python Modules with pip”
and read “Intro to Beautiful Soup” for an overview of how
this tool works. In the transliterator module, we will load Beautiful
Soup and then turn our converted page into a Beautiful Soup object.

#load Beautiful Soup
from bs4 import BeautifulSoup

#convert the page
converted_soup = BeautifulSoup(converted_content)

The lesson “Intro to Beautiful Soup” teaches how to grab sections of
a web page by their tags. But we can also select sections of the page by
attributes, HTML code that modifies elements. Looking at the HTML from
this page, notice that the text of our names are enclosed in the tag
<p>. The class attribute allows the page’s Cascading
Style Sheets (CSS) settings to change the look of all elements that
share the “name” class at once. CSS itself is an important tool for web
designers. For those interested in learning more on this aspect of CSS,
I recommend Code Academy’s interactive lessons in its web
fundamentals track. In mining data from the web, though, attributes like
class give us a pattern to separate out certain values.

What we want is to get the elements where the class attribute’s value is
“name”. When dealing with most types of attributes, Beautiful Soup can
select parts of the page using the same syntax as HTML. The class
attribute makes things a little tricky because Python uses “class” to
define new types of objects. Beautiful Soup gets around this by making
us search for class followed by an underscore: class_="value".
Beautiful Soup objects’ .find_all() method will generate a Python list
of Beautiful Soup objects that match the HTML tags or attributes set as
parameters. The method .get_text() extracts just the text from
Beautiful Soup objects, so
" <p><a name="n1"></a>A-Aku Tulikovich</p> ". get_text()
will become “A-Aku Tulikovich”. We need to use .get_text() on each
item in the list, then append it to a new list containing just the
names:

#creating the final names list
names = []

#creating the list with .find_all() and looping through it
for entry in converted_soup.find_all(class_="name"):
    names.append(entry.get_text())

To make sure it worked, let’s check the number of names and then see if
they look like we expect:

#check the number of names
len(names)

> 190

#see the first twenty names in the list
names[:20]

> ['A-Aku Tulikovich ', 'Aab Avgust Mikhailovich', 'Aab Avgust Khristianovich', 'Aab Aleksandr Aleksandrovich', "Aab Aleksandr Khrist'ianovich", "Aab Al'bert Viktorovich", "Aab Al'brekht Aleksandrovich", 'Aab Amaliia Andreevna', 'Aab Amaliia Ivanovna', 'Aab Angelina Andreevna', 'Aab Andrei Andreevich', 'Aab Andrei Filippovich', 'Aab Arvid Karlovich', "Aab Arnol'd Aleksandrovich", 'Aab Artur Avgustovich', "Aab Artur Vil'gel'movich", "Aab Aelita Arnol'dovna", 'Aab Viktor Aleksandrovich', 'Aab Viktor Aleksandrovich', "Aab Viktor Vil'gel'movich"]

Transliteration can only do so much. Except for proper names, it can
tell you little about the content of the source being transliterated.
Yet the ability to transliterate automatically is of great use when
dealing with lots of names or for people who prefer or need to use ASCII
characters. It is a simple tool but one that can be an enormous time
saver.

Юникод в Python — Введение в Python

Введение в Python

Видео может быть заблокировано из-за расширений браузера. В статье вы найдете решение этой проблемы.

Unicode in Python

Before the Unicode

• Memory consists of bytes
• A string is a chain of bytes
• One byte can have up to 256 values
• One byte can mark one of 256 symbols
• To print a byte, you should find a symbol that it marks…
• … with a special table, named Code page

ASCII Code page

• a special table that compares bytes with symbols
• ASCII table as a standard
• 0. .127 for latin and system symbols
• 128..255 for extended symbols

How about foreign languages?

• 0..127 for latin and system symbols anyway
• 128..255 for realm-specific symbols
• One realm — one code page
• cp866 DOS-Cyrillic
• cp1251 Windows-Cyrillic
• cp1253 Windows-Creek
• etc

Encoding hell

• Lots of code pages
• Every message should declare the code page
• Encode/decode errors, strange symbols instead of text
• Remember your inbox 10 years ago

How does it fail

• User A types "Привет" on Linux (utf-8)
• The bytes are \xd0\x9f\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82
• The program should send a header with encoding, but it doesn’t
• User B receives the message without header on Windows (cp1251)
• So default code page becomes cp1251
• Decoded message is Привет
• :—(

The solution is Unicode

• It’s a common unlimited alphabet
• Every symbol has its own number
• Unicode is growing
• U+XXXX to refer a specific code

U+0031      1
U+00A9      ©
U+20AC      €
U+266B      ♫
U+4E64      乤
U+45B4      䖴

What is UTF?

• An algorithm how turn Unicode into bytes and read it back
• There are UTF-8, -16 and -32 encodings
• UTF-8 uses 1 byte for latin and 2 bytes for non-latin
• UTF-8 is compatible with english text
• Can encode large subset of Unicode

Still have problems with Unicode?

• Try to use UTF-8 encoding everywhere
• Read Joel Spolsky «About Unicode and Character Sets»

Unicode in Python 2. x

• Unicode strings are declared with u'...' prefix
• The should be coding directive in your file
• Use \uXXXX to refer unicode symbols 0..FFFF
• \UXXXXXXXX to refer 0..FFFFFFFF symbols (rare)

# coding=utf-8           # -*- coding: utf-8 -*-
name = u'Иван'
name = u'Ιαννης'
name = u'João'
greet = u'\u041f\u0440\u0438\u0432\u0435\u0442'
print greet
>>> Привет
print u'\U0000041f\U00000440\U00000438\U00000432\U00000435\U00000442'
>>> Привет

data = u"""
Any string in english
Любая строка на русском
任何字符串在中國"""

print data
Any string in english
Любая строка на русском
任何字符串在中國

repr(data)
u'\nAny string in english\n\u041b\u044e\u0431\u0430\u044f \u0441\u0442\u0440\u043e\u043a\u0430 \u043d\u0430 \u0440\u0443\u0441\u0441\u043a\u043e\u043c\n\u4efb\u4f55\u5b57\u7b26\u4e32\u5728\u4e2d\u570b\n'

How to turn an object into Unicode

unicode([1, 2, True, {"test": 42}])
>>> u"[1, 2, True, {'test': 42}]"

unicode(obj) == obj. __unicode__()

class User(object):
    def __unicode__(self):
        return u'%s %s' % (self.name, self.surname)

user = User(...)
unicode(user)  # u'Михаил Паниковский'

How to turn a 8-bit string into Unicode

message = '\xcf\xf0\xe8\xe2\xe5\xf2'
decoded = message.decode('cp1251')
repr(decoded)
>>> u'\u041f\u0440\u0438\u0432\u0435\u0442'
print decoded
Привет

message = '\x8f\xe0\xa8\xa2\xa5\xe2'
decoded = unicode(message, 'cp866')
>>> Привет

How to turn a Unicode into 8-bit string

udata = u'Сообщение'
udata.encode('cp1251')
>>> '\xd1\xee\xee\xe1\xf9\xe5\xed\xe8\xe5'
udata.encode('utf-8')
>>> '\xd0\xa1\xd0\xbe\xd0\xbe\xd0\xb1\xd1\x89\xd0\xb5\xd0\xbd\xd0\xb8'

Encode/decode chaining

u'Иван'.encode('cp866').decode('cp866')
>>> u'\u0418\u0432\u0430\u043d'

'\x88\xa2\xa0\xad'.decode('cp866').encode('utf-8')
>>> '\xd0\x98\xd0\xb2\xd0\xb0\xd0\xbd'

Encode/Decode errors

>>> u'Ivan'. encode('cp1251')
'Ivan'

>>> u'Иван'.encode('cp1251')
'\xc8\xe2\xe0\xed'

>>> u'任何字符串在中國'.decode('cp1251')
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-7: ordinal not in range(128)

The meaning of strings

• Unicode is a human string
• 8-bit string is just bytes
• Avoid printing bytes
• The result depends on locale, code page, etc

Don’t mix unicode and 8-bit strings!

u'Привет, ' + 'Ivan'
Привет, Ivan

u'Привет, ' + 'Иван'
>>> UnicodeDecodeError: 'ascii' codec can't decode byte 0xd0 in position 0: ordinal not in range(128)

name = '\xd0\x98\xd0\xb2\xd0\xb0\xd0\xbd'
u'Привет, ' + name.decode('utf-8')
>>> Привет, Иван

Methods are same

data = u'Юникод и Ко'
data.upper()                # ЮНИКОД И КО
data.lower()                # юникод и ко
data.split(u' ')
>>> [u'\u042e\u043d\u0438\u043a\u043e\u0434', u'\u0438', u'\u041a\u043e']
data. replace(u'Ко', u'Компания')       # Юникод и Компания

Остались вопросы? Задайте их в разделе «Обсуждение»

Вам ответят команда поддержки Хекслета или другие студенты.

Зарегистрироваться

или
войти в аккаунт

Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно.

• 115 курсов, 2000+ часов теории

• 800 практических заданий в браузере

• 250 000 студентов

Наши выпускники работают в компаниях:

игры в ASCII-арте на Python3.6+ / Хабр

Для своих игр в ASCII-арте я написал библиотеку bear_hug с очередью событий, коллекцией виджетов, поддержкой ECS и прочими полезными мелочами. В этой статье мы посмотрим, как с её помощью сделать минимальную работающую игру.

Дисклеймеры

• Я единственный разработчик библиотеки, поэтому могу быть предвзят.
• bear_hug – по сути обёртка вокруг bearlibterminal, поэтому относительно низкоуровневых операций с глифами не будет.
• Похожая функциональность есть в clubsandwich, но я им не пользовался и сравнивать не могу.

Под капотом у bear_hug – bearlibterminal, библиотека на SDL для создания псевдо-консольного окна. То есть в чистом TTY, как какой-нибудь ncurses, она работать не будет. Но зато картинка получается одинаковой что на Linux, что на Windows, и не зависит от настроек пользовательского терминала. Это важно, особенно для игр, потому что при смене шрифта ASCII-арт вполне может превратиться Бог весть во что:

Один и тот же рисунок в оригинальном виде и после копипаста в разные программы

Разумеется, библиотека писалась для относительно масштабных проектов. Но, чтобы не отвлекаться на геймдизайн и архитектуру, в этой статье мы будем создавать что-нибудь простенькое. Проект на один вечер, в котором есть на чём показать основные функции библиотеки. А именно – упрощённый клон тех самых танчиков с Денди (они же Battle City). Будут танк игрока, танки противников, разрушаемые стены, звук и подсчёт очков. А вот главного меню, уровней и подбираемых бонусов не будет. Не потому, что их было бы невозможно добавить, а потому что этот проект – не более чем хэлловорлд.

Геймовер будет, а победы не будет. Потому что жизнь — боль.

Весь использованный в статье материал есть на гитхабе; сама библиотека – там же и на PyPI (под лицензией MIT).

Прежде всего нам понадобятся ассеты. Для рисования ASCII-арта я использую REXpaint от Джоша Ге (он же Kyzrati), разработчика научно-фантастического рогалика Cogmind. Редактор бесплатный, хоть и не опенсорсный; официальная версия есть только для Windows, но всё прекрасно работает под wine. Интерфейс довольно понятный и удобный:

Сохраняем в местный двоичный формат .xp и копируем из /path/to/rexpaint/images в папку с будущей игрой. В принципе поддерживается и загрузка изображений из .txt-файлов, но в текстовом файле очевидно невозможно сохранить цвета отдельных символов. Да и редактировать ASCII-арт в блокноте лично мне неудобно. Чтобы не хардкодить координаты и размер каждого элемента – эти данные хранятся в отдельном JSON-файле:

battlecity.json

[
  {
    "name": "player_r",
    "x": 1,
    "y": 2,
    "xsize": 6,
    "ysize": 6
  },
  {
    "name": "player_l",
    "x": 1,
    "y": 8,
    "xsize": 6,
    "ysize": 6
  },
  ...
]

Звуки под свободными лицензиями качаем из интернета. Пока что поддерживается только .wav. На этом с ассетами всё, можно начинать кодить. Прежде всего надо инициализировать терминал и очередь событий.game.py

# Терминал
terminal = BearTerminal(font_path='cp437_12x12.png',
                        size='91x60', title='AsciiCity',
                        filter=['keyboard', 'mouse'])
# Очередь событий
dispatcher = BearEventDispatcher()
# Цикл, который считает тики и вообще следит за временем
loop = BearLoop(terminal, dispatcher)

Терминал – это собственно окно игры. На него можно помещать виджеты, и он же по мере необходимости кидает события ввода. В качестве ключей при создании терминала можно использовать все опции терминала bearlibterminal; в данном случае мы задали шрифт, размер окна (в символах), заголовок окна и интересующие нас методы ввода.

Что касается очереди событий, то у неё очень простой интерфейс: dispatcher.add_event(event) добавляет событие в очередь, а dispatcher.register_listener(listener, event_types) позволяет на неё подписаться. У подписывающегося (например, виджета или компонента) должен быть коллбэк on_event, который принимает событие в качестве единственного аргумента и либо ничего не возвращает, либо возвращает другое событие или набор событий. Само событие состоит из типа и значения; тип тут не в смысле str или int, а в смысле “разновидность”, например ‘key_down’ или ‘tick’. Очередь принимает только события известных ей типов (встроенных или созданных пользователем) и отдаёт их в on_event всех подписавшихся на данный тип. Значения она никак не проверяет, но в пределах библиотеки есть соглашения по поводу того, что является валидным значением для каждого типа событий.

Сперва мы подписываем на очередь пару Listeners. Это базовый класс для объектов, которые могут подписываться на события, но не являются не виджетами, ни компонентами. В принципе использовать его не обязательно, лишь бы у подписывающегося был метод on_event.

Listeners

# Обрабатывает закрытие игрового окна операционной системой
dispatcher.register_listener(ClosingListener(), ['misc_input', 'tick'])
# Отслеживает все созданные и уничтоженные сущности
dispatcher.register_listener(EntityTracker(), ['ecs_create', 'ecs_destroy'])
# Играет звуки
jukebox = SoundListener({'shot': 'shot.wav',
                         'explosion': 'explosion.wav'})
# https://freesound.org/people/EMSIarma/sounds/108852/
# https://freesound.org/people/FlashTrauma/sounds/398283/
dispatcher.register_listener(jukebox, 'play_sound')

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

# О значениях очередь ничего не знает, поэтому ей достаточно
# названия типа
dispatcher.register_event_type('ac_damage')
# Дебажим наш новый тип и звуки
logger = LoggingListener(sys.stderr)
dispatcher.register_listener(logger, ['ac_damage', 'play_sound'])

Договоримся, что в качестве значения у этого события будет кортеж из ID той сущности, которой нанесён урон, и значение урона. LoggingListener – просто инструмент для дебага, который печатает все полученные события куда скажут, в данном случае в stderr. В данном случае я хотел убедиться, что урон проходит корректно, а звук запрашивается всегда, когда должен.

С Listeners пока всё, можно добавить первый виджет. У нас это игровое поле класса ECSLayout. Это такой Layout, который умеет помещать на себя виджеты сущностей и перемещать их в ответ на события ecs_move, а заодно считает коллизии. Как и у большинства виджетов, у него два обязательных аргумента: вложенный список символов (возможно, пустых – пробел или None) и вложенный список цветов для каждого символа. В качестве цветов принимаются именованные цвета, RGB в формате `0xAARRGGBB` (либо `0xARGB`, `0xRGB`, `0xRRGGBB`) и в формате ‘#fff’. Размеры обоих списков должны совпадать; в противном случае выбрасывается исключение.

Первый виджет

# Создаём поле боя. Оно 84х60, а экран 91х60.
# 7 столбцов справа пойдут под счётчики хитпойнтов и очков
chars = [[' ' for x in range(84)] for y in range(60)]
colors = copy_shape(chars, 'gray')
layout = ECSLayout(chars, colors)
# 'all' - специальное значение, подписывающее на все типы событий
dispatcher.register_listener(layout, 'all')

Раз у нас теперь есть, на чём размещать внутриигровые объекты, можно начать создавать сущности. Весь код сущностей и компонентов вынесен в отдельный файл. Простейшая из них – разрушаемая кирпичная стена. Она умеет находиться на определённом месте, отображать свой виджет, служить объектом коллизии и получать урон. После достаточного количества урона стена исчезает.entities.py

def create_wall(dispatcher, atlas, entity_id, x, y):
    # Объект сущности
    wall = Entity(entity_id)
    # Компоненты
    wall.add_component(PositionComponent(dispatcher, x, y))
    wall.add_component(CollisionComponent(dispatcher))
    wall.add_component(PassingComponent(dispatcher))
    wall.add_component(DestructorComponent(dispatcher))
    # Виджет тоже завёрнут в компонент, но сперва его надо создать
    # А для этого - подгрузить символы/цвета из атласа
    images_dict = {'wall_3': atlas.get_element('wall_3'),
                   'wall_2': atlas.get_element('wall_2'),
                   'wall_1': atlas.get_element('wall_1')}
    wall.add_component(SwitchWidgetComponent(dispatcher,
                                             SwitchingWidget(images_dict=images_dict,
                                                             initial_image='wall_3')))
    wall.add_component(VisualDamageHealthComponent(dispatcher,
                                                   hitpoints=3,
                                                   widgets_dict={3: 'wall_3',
                                                                 2: 'wall_2',
                                                                 1: 'wall_1'}))
    # Объявляем о создании сущности
    dispatcher. add_event(BearEvent('ecs_create', wall))
    dispatcher.add_event(BearEvent('ecs_add', (wall.id,
                                               wall.position.x,
                                               wall.position.y)))

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

Из не-встроенных компонентов тут только здоровье. Я создал базовый класс “Компонент здоровья” и унаследовал от него “Компонент здоровья, меняющий виджет” (чтобы показывать стену целой и на нескольких стадиях разрушения).

class HealthComponent

class HealthComponent(Component):
    def __init__(self, *args, hitpoints=3, **kwargs):
        super().__init__(*args, name='health', **kwargs)
        self.dispatcher.register_listener(self, 'ac_damage')
        self._hitpoints = hitpoints

    def on_event(self, event):
        if event.event_type == 'ac_damage' and event.event_value[0] == self.owner.id:
            self.hitpoints -= event.event_value[1]

    @property
    def hitpoints(self):
        return self._hitpoints

    @hitpoints.setter
    def hitpoints(self, value):
        if not isinstance(value, int):
            raise BearECSException(
                f'Attempting to set hitpoints of {self.owner.id} to non-integer {value}')
        self._hitpoints = value
        if self._hitpoints < 0:
            self._hitpoints = 0
        self.process_hitpoint_update()

    def process_hitpoint_update(self):
        """
        Should be overridden by child classes.
        """
        raise NotImplementedError('HP update processing should be overridden')

    def __repr__(self):
        # Сериализация не используется этой игрой и приведена только для примера
        return dumps({'class': self. __class__.__name__,
                      'hitpoints': self.hitpoints})

При создании компонента в super().__init__ передаётся ключ ‘name’. Когда компонент будет добавлен к какой-нибудь сущности, под названием из этого ключа он будет добавлен в __dict__ сущности и к нему можно будет обращаться через entity_object.health. Помимо удобства интерфейса, такой подход хорош тем, что запрещает выдавать сущности несколько однородных компонентов. А то, что он хардкодится внутри компонента, не позволяет по ошибке засунуть, например, WidgetComponent в слот компонента здоровья. Сразу при создании компонент подписывается на интересующие его классы событий, в данном случае ac_damage. Получив такое событие, метод on_event проверит, не о его ли хозяине часом речь. Если да – он вычтет нужное значение из хитпойнтов и дёрнет коллбэк на изменение здоровья, у базового класса абстрактный. Ещё есть метод __repr__, который используется для сериализации в JSON (например, для сохранений). Его добавлять не обязательно, но у всех встроенных компонентов и большинства встроенных виджетов он есть.

Наследующий от базового компонента здоровья VisualDamageHealthComponent переопределяет коллбэк на изменение здоровья:

class VisualDamageHealthComponent

class VisualDamageHealthComponent(HealthComponent):
    """
    Меняет виджет хозяина по достижении порогового урона.
    Уничтожает хозяина при HP=0
    """
    def __init__(self, *args, widgets_dict={}, **kwargs):
        super().__init__(*args, **kwargs)
        self.widgets_dict = OrderedDict()
        for x in sorted(widgets_dict.keys()):
            self.widgets_dict[int(x)] = widgets_dict[x]

    def process_hitpoint_update(self):
        if self.hitpoints == 0 and hasattr(self.owner, 'destructor'):
            self.owner.destructor.destroy()
        for x in self.widgets_dict:
            if self.hitpoints >= x:
                self.owner.widget.switch_to_image(self.widgets_dict[x])

Пока здоровье выше 0, он просит компонент, ответственный за виджет, отрисовывать стену в нужном состоянии. Тут как раз используется описанное выше обращение через атрибут объекта сущности. Как только хитпойнты кончатся, таким же образом будет вызван компонент, ответственный за корректное уничтожение сущности и всех компонентов.

Для остальных сущностей всё аналогично, только набор компонентов другой. Танкам добавляются контроллеры (ввод для игрока, ИИ для противников) и поворачивающиеся виджеты, снарядам – компонент коллизии, наносящий урон тем, в кого они попали. Разбирать каждый из них я не буду, потому что это громоздко и довольно тривиально; посмотрим только на коллайдер снаряда. У него есть метод collided_into, вызываемый, когда сущность-хозяин во что-то врезалась:

коллайдер-компонент пули

def collided_into(self, entity):
        if not entity:
            self.owner.destructor.destroy()
        elif hasattr(EntityTracker().entities[entity], 'collision'):
            self.dispatcher.add_event(BearEvent(event_type='ac_damage',
                                                event_value=(
                                                entity, self. damage)))
            self.owner.destructor.destroy()

Чтобы убедиться, что в жертву действительно можно попасть (что может быть не так для, например, элементов фона), снаряд использует EntityTracker(). Это синглетон, который отслеживает все создаваемые и уничтожаемые сущности; через него можно получить объект сущности по имени и что-нибудь сделать с его компонентами. В данном случае проверяется, что entity.collision (обработчик коллизий жертвы) вообще существует.

Теперь в основном файле игры мы просто вызываем все необходимые функции создания сущностей:

Возвращаемся в game.py

# Загружаем атлас, функции-создатели сущностей в нём нуждаются
atlas = Atlas(XpLoader('battlecity.xp'),
              'battlecity.json')
# Танк игрока
create_player_tank(dispatcher, atlas, 30, 50)
# Карта уровня захардкожена
wall_array = [[0 for _ in range(14)],
              [0 for _ in range(14)],
              [1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
              [1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0],
              [1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1],
              [1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0],
              [1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0],
              [0 for _ in range(14)],
              [0 for _ in range(14)],
              [0 for _ in range(14)]
              ]
for y in range(10):
    for x in range(14):
        if wall_array[y][x] == 1:
            create_wall(dispatcher, atlas, f'wall{x}{y}', x*6, y*6)
# Вражеский штаб - просто рисунок.  У него даже коллайдера нет.
create_spawner_house(dispatcher, atlas, 35, 0)

Счётчики очков и хитпойнтов не являются сущностями и не находятся на поле боя. Поэтому они добавляются не на ECSLayout, а прямо на терминал справа от карты. Соответствующие виджеты наследуют от Label (виджет текстового вывода) и имеют метод on_event, чтобы узнавать о том, что их интересует. В отличие от Layout, терминал не обновляет виджеты автоматически каждый тик, поэтому после изменения текста виджеты приказывают ему это сделать:listeners.py

class ScoreLabel(Label):
    """
    Счётчик очков
    """
    def __init__(self, *args, **kwargs):
        super().__init__(text='Score:\n0')
        self.score = 0

    def on_event(self, event):
        if event.event_type == 'ecs_destroy' and 'enemy' in event.event_value and 'bullet' not in event.event_value:
            # Уничтожен вражеский танк
            self.score += 10
            self.text = f'Score:\n{self.score}'
            self. terminal.update_widget(self)


class HPLabel(Label):
    """
    Счётчик хитпойнтов
    """
    def __init__(self, *args, **kwargs):
        super().__init__(text='HP:\n5')
        self.hp = 5

    def on_event(self, event):
        if event.event_type == 'ac_damage' and event.event_value[0] == 'player':
            self.hp -= event.event_value[1]
            self.text = f'HP:\n{self.hp}'
            self.terminal.update_widget(self)

Генератор врагов и объект, ответственный за вывод “GAME OVER”, на экране не представлены вовсе, поэтому они наследуют от Listener. Принцип тот же: объекты слушают очередь, дожидаются нужного момента, а потом создают сущность или виджет.геймовер

# Спаунер не приведён из-за громоздкости. См. репозиторий.
class GameOverListener(Listener):
    """
    Отрисовывает целевой виджет после смерти игрока
    """
    def __init__(self, *args, widget=None, **kwargs):
        print (args)
        super().__init__(*args, *kwargs)
        self. widget = widget

    def on_event(self, event):
        if event.event_type == 'ecs_destroy' and event.event_value == 'player':
            self.terminal.add_widget(self.widget,
                                     pos=(20, 20),
                                     layer=5)

Теперь мы создали всё, что нужно, и можем запускать игру. Запускаем

# Виджеты создаются и подписываются так же, как и Listeners в начале статьи
terminal.start()
terminal.add_widget(layout)
terminal.add_widget(score, pos=(85, 10))
terminal.add_widget(hp, pos=(85, 15))

Виджеты добавляются на экран только после его запуска. Сущности можно было добавлять на карту и раньше – события создания (в которых хранится вся сущность, включая виджет) просто копятся в очереди и разрешаются на первом тике. А вот терминал умеет добавлять виджеты только после того, как для него будет успешно создано окно.

К этому моменту у нас есть работающий прототип, можно выпускаться в Early Access за двадцать баксов добавлять фичи и полировать геймплей. Но это уже выходит за рамки хэллоуворлда, а значит – и статьи. Добавлю только, что не зависящий от системного питона билд можно собрать с помощью pyinstaller.

ascii () в Python — GeeksforGeeks

ascii () в Python

ascii () возвращает строку, содержащую печатное представление объекта, и экранирует символы, отличные от ASCII, в строке с помощью \ x, \ u или \ U escape-символов .

  Синтаксис:  ascii (объект)

 

Метод может принимать только один параметр, объект, который может быть списком, строками и т. Д.Как уже говорилось, он возвращает печатное представление объекта.

Примеры:

 Ввод: ascii ("¥")
Вывод: '\ xa5'

Ввод: ascii ("µ")
Вывод: '\ xb5'

Ввод: ascii ("Ë")
Вывод: '\ xcb'


 

Мы видим, что в этих примерах все символы, отличные от ASCII, были экранированы, то есть их закодированный код отображается с помощью метода ascii ().
Пример:

Python3

Выход:

 'G \ xeb \ xea k s f? r G? e k s '
 

Автор статьи Чинмой Ленка .Если вам нравится GeeksforGeeks, и вы хотели бы внести свой вклад, вы также можете написать статью с помощью provide.geeksforgeeks.org или отправить ее по электронной почте на [email protected]. Смотрите, как ваша статья появляется на главной странице GeeksforGeeks, и помогайте другим гикам.
Пожалуйста, напишите комментарий, если вы обнаружите что-то неправильное, или вы хотите поделиться дополнительной информацией по теме, обсужденной выше.

Внимание компьютерщик! Укрепите свои основы с помощью курса Python Programming Foundation и изучите основы.

Для начала подготовьтесь к собеседованию. Расширьте свои концепции структур данных с помощью курса Python DS .

curses.ascii — Утилиты для символов ASCII — документация Python 3.9.1

Модуль curses.ascii предоставляет константы имен для символов ASCII и
функции для проверки принадлежности к различным классам символов ASCII. Константы
В комплект поставки входят следующие имена управляющих символов:

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

Модуль обеспечивает следующие функции, аналогичные стандартным
Библиотека C:

curses.ascii. isalnum ( c )

Проверяет наличие буквенно-цифрового символа ASCII; это эквивалентно isalpha (c) или
isdigit (c) .

curses.ascii. isalpha ( c )

Проверяет наличие буквенного символа ASCII; это эквивалентно isupper (c) или
Ислауэр (с) .

curses.ascii. isascii ( c )

Проверяет значение символа, которое соответствует 7-битному набору ASCII.

curses.ascii. пустой ( c )

Проверяет наличие символа пробела ASCII; пробел или горизонтальная табуляция.

curses. ascii. iscntrl ( с )

Проверяет наличие управляющего символа ASCII (в диапазоне от 0x00 до 0x1f или 0x7f).

curses.ascii. isdigit ( c )

Проверяет наличие десятичной цифры ASCII, от '0' до '9' . Это эквивалентно
до c в строке. цифры .

curses.ascii. исграф ( c )

Проверяет наличие в ASCII любого печатаемого символа, кроме пробела.

curses.ascii. нижняя ( c )

Проверяет наличие символа нижнего регистра ASCII.

curses.ascii. исприн ( c )

Проверяет наличие любого печатаемого символа ASCII, включая пробел.

curses.ascii. ispunct ( c )

Проверяет наличие любого печатаемого символа ASCII, не являющегося пробелом или буквенно-цифровым символом.
персонаж.

curses.ascii. isspace ( с )

Проверяет наличие пробелов ASCII; пробел, перевод строки, возврат каретки, форма
канал, горизонтальная вкладка, вертикальная вкладка.

curses.ascii. верхний ( c )

Проверяет наличие буквы ASCII в верхнем регистре.

curses.ascii. isxdigit ( c )

Проверяет наличие шестнадцатеричной цифры ASCII. Это эквивалентно c в
строка. шестнадцатеричные цифры .

curses.ascii. isctrl ( с )

Проверяет наличие управляющего символа ASCII (порядковые значения от 0 до 31).

curses.ascii. исмета ( c )

Проверяет наличие символа, отличного от ASCII (порядковые значения 0x80 и выше).

Эти функции принимают целые числа или односимвольные строки; когда аргумент
строка, она сначала преобразуется с помощью встроенной функции ord () .

Обратите внимание, что все эти функции проверяют порядковые битовые значения, полученные из
символ строки, которую вы передаете; они фактически ничего не знают о
кодировка символов хост-машины.

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

curses.ascii. ascii ( c )

Вернуть значение ASCII, соответствующее младшим 7 битам c .

curses.ascii. упор ( c )

Вернуть управляющий символ, соответствующий данному символу (символ
битовое значение имеет побитовое значение 0x1f).

curses.ascii. альт ( c )

Вернуть 8-битный символ, соответствующий данному символу ASCII (
битовое значение символа побитовое с 0x80).

Следующая функция принимает односимвольную строку или целочисленное значение;
он возвращает строку.

curses.ascii. unctrl ( c )

Вернуть строковое представление символа ASCII c .? ‘ . Если у символа установлен мета-бит (0x80), мета-бит
удаляется, применяются предыдущие правила и '!' добавлено к результату.

curses.ascii. управляющие имена

Строковый массив из 33 элементов, содержащий мнемонику ASCII для тридцати двух
Управляющие символы ASCII от 0 (NUL) до 0x1f (US), по порядку, плюс мнемоника
SP для символа пробела.

binascii — Преобразование между двоичным кодом и ASCII — Python 3.9.1 документация

Модуль binascii содержит ряд методов для преобразования между
двоичные и различные двоичные представления в кодировке ASCII. Обычно вы не будете
используйте эти функции напрямую, но используйте модули-оболочки, такие как uu ,
base64 или binhex . Модуль binascii содержит
низкоуровневые функции, написанные на C для большей скорости, которые используются
модули более высокого уровня.

Примечание

a2b_ * Функции принимают строки Unicode, содержащие только символы ASCII.Другие функции принимают только байтовые объекты (например,
байта , байта, массив и другие объекты, поддерживающие буфер
протокол).

Изменено в версии 3.3: строки Unicode, содержащие только ASCII, теперь принимаются функциями a2b_ * .

Модуль binascii определяет следующие функции:

binascii. a2b_uu ( строка )

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

binascii. b2a_uu ( данные , * , обратная кавычка = False )

Преобразует двоичные данные в строку символов ASCII, возвращаемое значение —
преобразованная строка, включая символ новой строки. Длина данных должна быть не более
45. Если обратная кавычка истинна, нули представлены как '' ' вместо пробелов.

Изменено в версии 3.7: Добавлен параметр обратной кавычки .

binascii. a2b_base64 ( строка )

Преобразует блок данных base64 обратно в двоичный и возвращает двоичные данные. Более
одновременно может быть передана не одна строка.

binascii. b2a_base64 ( данные , * , перевод строки = True )

Преобразует двоичные данные в строку символов ASCII в кодировке base64. Возврат
значение — преобразованная строка, включая символ новой строки, если новая строка
истинный. Выходные данные этой функции соответствуют RFC 3548 .

Изменено в версии 3.6: Добавлен параметр новой строки .

binascii. a2b_qp ( data , header = False )

Преобразовать блок данных для печати в кавычки обратно в двоичный и вернуть двоичный
данные. Одновременно может быть передано более одной строки.Если необязательный аргумент
Заголовок присутствует и является истинным, подчеркивания будут декодированы как пробелы.

binascii. b2a_qp ( data , quotetabs = False , istext = True , заголовок = False )

Преобразование двоичных данных в строку (строки) символов ASCII в кавычках для печати
кодирование. Возвращаемое значение — преобразованная строка (строки). Если необязательный аргумент
quotetabs присутствует и истинно, все табуляции и пробелы будут закодированы.Если
необязательный аргумент istext присутствует и истина, новые строки не кодируются, но
завершающие пробелы будут закодированы. Если необязательный аргумент заголовок равен
присутствует и истина, пробелы будут закодированы как символы подчеркивания согласно RFC 1522 . Если
необязательный аргумент заголовок присутствует и false, символы новой строки будут
также закодированы; в противном случае преобразование перевода строки может повредить двоичные данные
транслировать.

binascii. a2b_hqx ( строка )

Преобразование данных ASCII в формате binhex4 в двоичные без выполнения RLE-декомпрессии.
Строка должна содержать полное количество двоичных байтов или (в случае
последняя часть данных binhex4), оставшиеся биты равны нулю.

Не рекомендуется, начиная с версии 3. 9.

binascii. rledecode_hqx ( данные )

Выполните RLE-декомпрессию данных в соответствии со стандартом binhex4.В
алгоритм использует 0x90 после байта в качестве индикатора повтора, за которым следует счетчик.
Счетчик 0 указывает значение байта 0x90 . Подпрограмма возвращает
распакованные данные, если только входные данные не оканчиваются индикатором повтора потерянных
в этом случае возникает исключение Incomplete .

Изменено в версии 3.2: Принимать в качестве входных данных только байтовые строки или байтовые массивы.

Не рекомендуется, начиная с версии 3.9.

binascii. rlecode_hqx ( данные )

Выполнить сжатие RLE в стиле binhex4 для данных и вернуть результат.

Не рекомендуется, начиная с версии 3.9.

binascii. b2a_hqx ( данные )

Выполнить преобразование двоичного кода hexbin4 в ASCII и вернуть полученную строку. В
аргумент должен быть уже закодирован RLE и иметь длину, кратную 3 (кроме
возможно последний фрагмент).

Не рекомендуется, начиная с версии 3.9.

binascii. crc_hqx ( данные , значение )

Вычислить 16-битное значение CRC данных , начиная со значения в качестве
начальный CRC и вернуть результат. Здесь используется полином CRC-CCITT
x ¹⁶ + x ¹² + x ⁵ + 1, часто обозначается как
0x1021. Этот CRC используется в формате binhex4.

binascii. crc32 ( данные [, значение ])

Вычислить CRC-32, 32-битную контрольную сумму данных , начиная с
начальный CRC значение . Начальный CRC по умолчанию равен нулю. Алгоритм
соответствует контрольной сумме ZIP-файла. Поскольку алгоритм рассчитан на
использовать в качестве алгоритма контрольной суммы, он не подходит для использования в качестве общего хеша
алгоритм. Используйте следующим образом:

 принт (binascii.crc32 (b "привет, мир"))
# Или из двух частей:
crc = binascii.crc32 (b "привет")
crc = binascii.crc32 (b "мир", crc)
print ('crc32 = {: # 010x}'. format (crc))
 

Изменено в версии 3.0: результат всегда беззнаковый.
Чтобы сгенерировать одно и то же числовое значение для всех версий Python и
платформы, используйте crc32 (данные) и 0xffffffff .

binascii. b2a_hex ( данные [, sep [, bytes_per_sep = 1 ]])

binascii. hexlify ( данные [, sep [, bytes_per_sep = 1 ]])

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

Аналогичная функциональность (но с возвратом текстовой строки) также удобно
доступно с использованием байта.hex () метод.

Если указано sep , это должен быть односимвольный объект str или bytes.
Он будет вставлен в вывод через каждые bytes_per_sep входных байтов.
Размещение разделителя по умолчанию отсчитывается от правого конца вывода,
если вы хотите считать слева, укажите отрицательное значение bytes_per_sep .

 >>> import binascii
>>> binascii.b2a_hex (b '\ xb9 \ x01 \ xef')
b'b901ef '
>>> binascii.hexlify (b '\ xb9 \ x01 \ xef', '-')
b'b9-01-ef '
>>> binascii.b2a_hex (b '\ xb9 \ x01 \ xef', b'_ ', 2)
b'b9_01ef '
>>> binascii.b2a_hex (b '\ xb9 \ x01 \ xef', b '', -2)
b'b901 ef '
 

Изменено в версии 3.8: добавлены параметры sep и bytes_per_sep .

binascii. a2b_hex ( hexstr )

binascii. unhexlify ( hexstr )

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

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

исключение binascii. Ошибка

Исключительная ситуация при ошибках.Обычно это ошибки программирования.

исключение binascii. Незавершенное

Исключительная ситуация при неполных данных. Обычно это не ошибки программирования,
но с этим можно справиться, прочитав еще немного данных и попробовав еще раз.

См. Также

Модуль base64

Поддержка RFC-совместимого кодирования в стиле base64 в base 16, 32, 64,
и 85.

Модуль binhex

Поддержка формата binhex, используемого на Macintosh.

Модуль uu

Поддержка кодировки UU, используемой в Unix.

Модуль quopri

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

Python: получить значение ASCII символа

DEC	окт	ШЕСТИГР.	БИН	Символ	HTML-номер	Имя HTML	Описание
128	200	80	10000000	€	& # 128;	и евро;	Знак евро
129	201	81	10000001
130	202	82	10000010	‚	& # 130;	& sbquo;	Одиночная кавычка с малым числом 9
131	203	83	10000011	ƒ	& # 131;	& fnof;	Строчная латинская буква f с крючком
132	204	84	10000100	„	& # 132;	& bdquo;	Двойная кавычка с малым числом 9
133	205	85	10000101	…	& # 133;	& hellip;	Горизонтальное многоточие
134	206	86	10000110	†	& # 134;	& кинжал;	Кинжал
135	207	87	10000111	‡	& # 135;	и кинжал;	Двойной кинжал
136	210	88	10001000	ˆ	& # 136;	& circ;	Буква-модификатор с циркумфлексом, ударение
137	211	89	10001001	‰	& # 137;	& permil;	Знак промилле
138	212	8A	10001010	Š	& # 138;	и Scaron;	Заглавная латинская буква S с кароном
139	213	8B	10001011	‹	& # 139;	& lsaquo;	Котировка с одним левым углом
140	214	8C	10001100	Œ	& # 140;	и OElig;	Лигатура латинской заглавной буквы OE
141	215	8D	10001101
142	216	8E	10001110	Ž	& # 142;		Заглавная латинская буква Z с кароном
143	217	8F	10001111
144	220	90	10010000
145	221	91	10010001	‘	& # 145;	& lsquo;	Левая одинарная кавычка
146	222	92	10010010	’	& # 146;	& rsquo;	Правая одинарная кавычка
147	223	93	10010011	“	& # 147;	& ldquo;	Левая двойная кавычка
148	224	94	10010100	”	& # 148;	& rdquo;	Правая двойная кавычка
149	225	95	10010101	•	& # 149;	и бык;	Пуля
150	226	96	10010110	–	& # 150;	& ndash;	Чертеж
151	227	97	10010111	–	& # 151;	& mdash;	Em dash
152	230	98	10011000	˜	& # 152;	& тильда;	Маленькая тильда
153	231	99	10011001	™	& # 153;	и торговля;	Знак товарного знака
154	232	9A	10011010	š	& # 154;	& scaron;	Строчная латинская буква S с кароном
155	233	9Б	10011011	›	& # 155;	& rsaquo;	Одиночная кавычка, указывающая вправо
156	234	9C	10011100	œ	& # 156;	& oelig;	Латинская строчная лигатура oe
157	235	9D	10011101
158	236	9E	10011110	×	& # 158;		Строчная латинская буква z с кароном
159	237	9F	10011111	Ÿ	& # 159;	и Yuml;	Заглавная латинская буква Y с тремой
160	240	A0	10100000		& # 160;	& nbsp;	Пространство неразрывное
161	241	A1	10100001	¡	& # 161;	& iexcl;	Перевернутый восклицательный знак
162	242	A2	10100010	¢	& # 162;	& cent;	Знак центов
163	243	A3	10100011	£	& # 163;	& фунт;	Знак фунта
164	244	A4	10100100	¤	& # 164;	& curren;	Знак валюты
165	245	A5	10100101	¥	& # 165;	иена;	Знак йены
166	246	A6	10100110	¦	& # 166;	& brvbar;	Труба, сломанный вертикальный стержень
167	247	A7	10100111	§	& # 167;	& sect;	Знак раздела
168	250	A8	10101000	¨	& # 168;	& uml;	Интервал диэрезиса — умлаут
169	251	A9	10101001	©	& # 169;	& копия;	Знак авторского права
170	252	AA	10101010	ª	& # 170;	& ordf;	Женский порядковый указатель
171	253	AB	10101011	«	& # 171;	& laquo;	Двойные угловые кавычки слева
172	254	переменного тока	10101100	¬	& # 172;	и нет;	Не подписывать
173	255	н. э.	10101101		& # 173;	& застенчивый;	Мягкий перенос
174	256	AE	10101110	®	& # 174;	и рег;	Знак зарегистрированной торговой марки
175	257	AF	10101111	¯	& # 175;	& macr;	Макрон интервала — черта
176	260	B0	10110000	°	& # 176;	& deg;	Знак градуса
177	261	B1	10110001	±	& # 177;	& plusmn;	Знак плюс или минус
178	262	B2	10110010	²	& # 178;	& sup2;	Надстрочный знак два — в квадрате
179	263	B3	10110011	³	& # 179;	& sup3;	Надстрочный трехзначный куб
180	264	B4	10110100	´	& # 180;	и острый;	Острый акцент — интервал острый
181	265	B5	10110101	µ	& # 181;	и микро;	Микроподпись
182	266	B6	10110110	¶	& # 182;	& пункт;	Знак Pilcrow — знак параграфа
183	267	B7	10110111	·	& # 183;	и миддот;	Средняя точка — грузинская запятая
184	270	B8	10111000	¸	& # 184;	& cedil;	Шаг седиль
185	271	B9	10111001	¹	& # 185;	& sup1;	Верхний индекс один
186	272	BA	10111010	º	& # 186;	& ordm;	Мужской порядковый указатель
187	273	BB	10111011	»	& # 187;	& raquo;	Кавычки с двойным прямым углом
188	274	г. до н.э.	10111100	¼	& # 188;	и frac14;	Дробь одна четверть
189	275	BD	10111101	½	& # 189;	и frac12;	Половина дроби
190	276	BE	10111110	¾	& # 190;	и frac34;	Дробь три четверти
191	277	BF	10111111	¿	& # 191;	& iquest;	Перевернутый вопросительный знак
192	300	C0	11000000	À	& # 192;	и Агрейв;	Заглавная латинская буква А с тупым ударением
193	301	C1	11000001	Á	& # 193;	& Aacute;	Заглавная латинская буква A с острым ударением
194	302	C2	11000010	Â	& # 194;	и Acirc;	Заглавная латинская буква A с циркумфлексом
195	303	C3	11000011	Ã	& # 195;	и Атилде;	Заглавная латинская буква A с тильдой
196	304	C4	11000100	Ä	& # 196;	и Auml;	Заглавная латинская буква A с тремой
197	305	C5	11000101	Å	& # 197;	& Aring;	Заглавная латинская буква A с кольцом над ним
198	306	C6	11000110	Æ	& # 198;	и AElig;	Заглавная латинская буква AE
199	307	C7	11000111	Ç	& # 199;	и Ccedil;	Заглавная латинская буква C с седилем
200	310	C8	11001000	È	& # 200;	и Эгрейв;	Заглавная латинская буква E с тупым ударением
201	311	C9	11001001	É	& # 201;	& Eacute;	Заглавная латинская буква E с острым ударением
202	312	CA	11001010	Ê	& # 202;	и Ecirc;	Заглавная латинская буква E с циркумфлексом
203	313	CB	11001011	Ë	& # 203;	и Euml;	Заглавная латинская буква E с тремой
204	314	CC	11001100	Ì	& # 204;	и Игрейв;	Заглавная латинская буква I с тупым ударением
205	315	CD	11001101	Í	& # 205;	& Iacute;	Заглавная латинская буква I с острым ударением
206	316	CE	11001110	Î	& # 206;	и Icirc;	Заглавная латинская буква I с циркумфлексом
207	317	CF	11001111	Ï	& # 207;	и Iuml;	Заглавная латинская буква I с тремой
208	320	D0	11010000	Ð	& # 208;	и ETH;	Заглавная латинская буква ETH
209	321	D1	11010001	Ñ	& # 209;	и Ntilde;	Заглавная латинская буква N с тильдой
210	322	D2	11010010	Ò	& # 210;	и Огрейв;	Заглавная латинская буква O с тупым ударением
211	323	D3	11010011	Ó	& # 211;	& Oacute;	Заглавная латинская буква O с острым ударением
212	324	D4	11010100	Ô	& # 212;	и Ocirc;	Заглавная латинская буква O с циркумфлексом
213	325	D5	11010101	Õ	& # 213;	и Otilde;	Заглавная латинская буква O с тильдой
214	326	D6	11010110	Ö	& # 214;	и Ouml;	Заглавная латинская буква O с тремой
215	327	D7	11010111	×	& # 215;	& раз;	Знак умножения
216	330	D8	11011000	Ø	& # 216;	и Ослаш;	Заглавная латинская буква O с косой чертой
217	331	D9	11011001	Ù	& # 217;	и Юграва;	Заглавная латинская буква U с тупым ударением
218	332	DA	11011010	Ú	& # 218;	и Uacute;	Заглавная латинская буква U с острым ударением
219	333	DB	11011011	Û	& # 219;	и Ucirc;	Заглавная латинская буква U с циркумфлексом
220	334	DC	11011100	Ü	& # 220;	и Uuml;	Заглавная латинская буква U с тремой
221	335	DD	11011101	Ý	& # 221;	& Yacute;	Заглавная латинская буква Y с острым ударением
222	336	DE	11011110	Þ	& # 222;	& THORN;	Заглавная латинская буква THORN
223	337	DF	11011111	ß	& # 223;	& szlig;	Строчная латинская буква, резкая s — ess-zed
224	340	E0	11100000	à	& # 224;	& agrave;	Строчная латинская буква А с тупым ударением
225	341	E1	11100001	á	& # 225;	& aacute;	Строчная латинская буква А с острым ударением
226	342	E2	11100010	â	& # 226;	и acirc;	Строчная латинская буква А с циркумфлексом
227	343	E3	11100011	ã	& # 227;	& atilde;	Строчная латинская буква А с тильдой
228	344	E4	11100100	ä	& # 228;	& auml;	Строчная латинская буква А с тремой
229	345	E5	11100101	å	& # 229;	& aring;	Строчная латинская буква А с кружком над ним
230	346	E6	11100110	æ	& # 230;	& aelig;	Строчная латинская буква ае
231	347	E7	11100111	ç	& # 231;	& ccedil;	Строчная латинская буква c с седилем
232	350	E8	11101000	и	& # 232;	& egrave;	Строчная латинская буква е с тупым ударением
233	351	E9	11101001	é	& # 233;	& eacute;	Строчная латинская буква e с острым ударением
234	352	EA	11101010	ê	& # 234;	и ecirc;	Строчная латинская буква e с циркумфлексом
235	353	EB	11101011	ë	& # 235;	& euml;	Строчная латинская буква e с тремой
236	354	EC	11101100	ì	& # 236;	& igrave;	Строчная латинская буква i с тупым ударением
237	355	ED	11101101	–	& # 237;	& iacute;	Строчная латинская буква i с острым ударением
238	356	EE	11101110	–	& # 238;	и icirc;	Строчная латинская буква i с циркумфлексом
239	357	EF	11101111	•	& # 239;	& iuml;	Строчная латинская буква i с тремой
240	360	F0	11110000	ð	& # 240;	& eth;	Строчная латинская буква eth
241	361	F1	11110001	—	& # 241;	& ntilde;	Строчная латинская буква n с тильдой
242	362	F2	11110010	х	& # 242;	& ograve;	Строчная латинская буква o с тупым ударением
243	363	F3	11110011	—	& # 243;	& oacute;	Строчная латинская буква o с острым ударением
244	364	F4	11110100	ô	& # 244;	& ocirc;	Строчная латинская буква o с циркумфлексом
245	365	F5	11110101	х	& # 245;	& otilde;	Строчная латинская буква O с тильдой
246	366	F6	11110110	ö	& # 246;	& ouml;	Строчная латинская буква o с тремой
247	367	F7	11110111	÷	& # 247;	& разделить;	Знак деления
248	370	F8	11111000	ø	& # 248;	& oslash;	Строчная латинская буква O с косой чертой
249	371	F9	11111001	ù	& # 249;	& ugrave;	Строчная латинская буква U с тупым ударением
250	372	FA	11111010	ú	& # 250;	и uacute;	Строчная латинская буква U с острым ударением
251	373	FB	11111011	û	& # 251;	& ucirc;	Строчная латинская буква u с циркумфлексом
252	374	FC	11111100	ü	& # 252;	& uuml;	Строчная латинская буква u с тремой
253	375	FD	11111101	ý	& # 253;	& yacute;	Строчная латинская буква y с острым ударением
254	376	FE	11111110	þ	& # 254;	& шип;	Строчная латинская буква шип
255	377	FF	11111111	ÿ	& # 255;	& yuml;	Строчная латинская буква y с циферблатом

Как использовать функцию Python ascii ()

В этой статье мы рассмотрим функцию Python ascii () .

Функция ascii () возвращает строковое представление объекта, но содержит только символы ASCII как есть.

Остальные символы, отличные от ASCII, будут экранированы обратной косой чертой (\). Например, символ новой строки ( \ n ) не является символом ASCII.

Теперь мы рассмотрим несколько примеров, чтобы понять, как это работает!

Использование функции Python ascii () — некоторые примеры

Функция Python ascii () принимает единственный аргумент, которым может быть любой объект.Итак, допустимы все виды объектов, такие как списки, строки и т. Д. Это вернет строку.

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

Давайте посмотрим на это сейчас.

Использование Python ascii () для примитивных типов данных

Для базовых типов данных, таких как boolean , string , int , они работают так, как вы ожидаете.

я = 15
печать (ascii (i))

b = верно
печать (ascii (b))

s = 'abc'
печать (ascii (s))

s = 'Привет от \ tAskPython \ n'
печать (ascii (s))
 

Выход

'15'
'Истинный'
"abc" "
"'Привет от \\ tAskPython \\ n'"
 

Как видите, для символов, отличных от ASCII (\ t, \ n), необходимо экранировать саму обратную косую черту.

Использование ascii () для итераций / коллекций

Если вы хотите использовать его в списке / кортеже / словаре, вы все равно можете! Но это просто применит его к каждому члену в коллекции / итерации.

Итак, если список содержит n элементов, мы получим функцию, примененную ко всем n из них, и вернем список строк.

m = ["Привет от AskPython 22", "AskPythön", "Привет"]
печать (ascii (m))
 

Выход

['Привет от AskPython 22', 'AskPyth \ xf6n', 'Привет']
 

Аналогичным образом, с помощью Dictionary { key : value } он будет применяться как к ключу , так и к значению .

d = {'â': 'å', '2': 2, 'ç': 'ć'}
печать (ascii (d))
 

Выход

{'\ xe2': '\ xe5', '2': 2, '\ xe7': '\ u0107'}
 

Для кортежа он аналогичен списку. Все элементы будут преобразованы в строковое представление символов, подобных ASCII.

t = ("Hellö", 123, ["AskPython"])
печать (ascii (t))
 

Выход

('Ад \ xf6', 123, ['AskPython'])
 

Сравнение с функцией repr ()

Функция repr () также используется для возврата строкового представления объектов.Но разница в том, что repr () печатает символы не ascii как таковые.

Для настраиваемых объектов функция ascii () внутренне вызывает функцию __repr __ () , но обеспечивает экранирование символов, отличных от ASCII.

Давайте поэкспериментируем с этим, создав наш собственный объект, используя класс.

класс MyClass:
    def __init __ (я, имя):
        self.name = имя
 

Теперь давайте создадим объект и попробуем вызвать на нем ascii () и repr () ,

my_obj = MyClass ("AskPythön")
печать (ascii (my_obj))
печать (repr (my_obj))
 

Выход

'<__ main__.Объект MyClass по адресу 0x7f6adcf30940> '
'<__ main __. MyClass объект в 0x7f6adcf30940>'
 

У нас нет функции repr () для этого класса, поэтому используется определение объекта по умолчанию. Вот почему в выводе вы видите объект MyClass .

Чтобы изменить это, мы должны сами перегрузить dunder-метод __repr __ () .

класс MyClass:
    def __init __ (я, имя):
        self.name = имя
    def __repr __ (сам):
        вернуть себя.имя
 

Теперь, когда вы вызываете ascii () или repr () , мы можем напрямую получить атрибут name!

my_obj = MyClass ("AskPythön")
печать (ascii (my_obj))
печать (repr (my_obj))
 

Выход

AskPyth \ xf6n
Спросите
 

Теперь вы четко видите разницу!

Заключение

В этой статье мы узнали об использовании функции ascii () в Python и научились использовать ее на разных типах объектов.

Список литературы

Метод Python ascii () — HowToDoInJava

Метод Python ascii () — это встроенная функция языка, которая возвращает строку, содержащую представление объекта для печати. ascii () экранирует символы, отличные от ASCII, в строке, используя escape-символы \ x , \ u или \ U .

1. Синтаксис

Синтаксис метода ascii () :

ascii (объект)
 

Здесь объект — это обязательный аргумент метода , и это может быть любой объект Python, такой как String, List, Tuple, Dictionary.

Возвращаемое значение — строка, содержащая только печатаемые символы. Все непечатаемые символы экранируются с использованием \ x , \ u или \ U и будут использовать кратчайшую доступную escape-последовательность между всеми тремя escape-символами.

Например, å будет заменено на \ xe5 .

2. Пример Python ascii ()

Простая программа на Python, которая печатает обычную строку, а затем другую строку, содержащую специальные символы.Мы также научимся использовать ascii () с объектом List .

simpleText = "Скалы Python"
печать (ascii (simpleText))

blogName = "HowToDoInJåvå"
печать (ascii (имя_бога))

nameList = ['как', 'делать', 'делать', 'в', 'jåvå']
печать (ascii (список имен))
 

Программный вывод.

'Скалы питона'

'HowToDoInJ \ xe5v \ xe5'

['как', 'к', 'делать', 'в', 'j \ xe5v \ xe5']
 

3. Разница между ascii () и ord ()

Python также имеет функцию ord () , которая возвращает числовое значение ASCII, соответствующее данному символу или символу.Например, значение ASCII буквы «B» равно 66. Все поддерживаемые символы см. В таблице ascii.

Заметная разница между обоими методами заключается в том, что метод ascii () работает для объектов, а весь метод ord () работает для любого заданного одиночного символа.

text = "jåvå"
печать (ascii (текст))

char = 'A'
печать (символ)

char = 'å'
печать (символ)
 

Программный вывод.

'j \ xe5v \ xe5'
А
å
 

Счастливого обучения !!

Был ли этот пост полезным?

Сообщите нам, понравился ли вам пост.Это единственный способ стать лучше.

арт · PyPI

Содержание

Обзор

ASCII-арт также известен как «компьютерное текстовое искусство». Он включает в себя умное размещение вводимых специальных символов или
буквы, чтобы создать визуальную форму, которая распределена по нескольким строкам текста.

ART — это библиотека Python для преобразования текста в художественное произведение ASCII. 😉

Использование

Быстрый старт

Арт.

В 1 линию

⚠️ Некоторые среды не поддерживают все однострочные рисунки

⚠️ ИСКУССТВО 4.6 — последняя версия, поддерживающая Двустороннее искусство

1. арт.

Эта функция возвращает однострочное изображение как str в обычном режиме и вызывает artError в исключении.

 >>> из импорта произведений искусства *
>>> art_1 = art ("coffee") # вернуть искусство как str в обычном режиме
>>> печать (art_1)
c [_]
>>> art_2 = art ("woman", number = 2) # вернуть несколько изображений как str
>>> печать (art_2)
▓⚗_⚗▓ ▓⚗_⚗▓
>>> art ("random") # режим произвольного рисования в одну линию
'(っ ◕‿◕) っ'
>>> art ("rand") # случайный режим рисования в одну линию
'т (-_- т)'
>>> art (22, number = 1) # поднять artError
Отслеживание (последний вызов последний):
        ...
art.art.artError: тип artname должен быть str.
 

2. aprint

Эта функция печатает однострочную графику в обычном режиме (возвращает None) и вызывает artError в исключении.

 >>> aprint ("бабочка") # print art
Ƹ̵̡Ӝ̵̨̄Ʒ
>>> aprint ("happy") # print art
 ۜ \ (סּ ں סּ َ`) / ۜ
>>> aprint ("random") # случайный режим рисования в одну линию
'(っ ◕‿◕) っ'
>>> aprint ("rand") # режим произвольной однострочной графики
'т (-_- т)'
>>> aprint ("woman", number = "22") # поднять artError
Отслеживание (последний вызов последний):
        ...
art.art.artError: тип 'number' должен быть int.
 

3. randart

randart функция добавлена ​​в Version 2.2 как ярлык art ("random") .

 >>> randart ()
'ዞ Ꮬ℘℘Ꮍ ℬℹℛʈዞᗬ ᏜᎽ'
>>> randart ()
'✌ (◕‿-) ✌'
 

• Примечание 1: используйте ART_NAMES для доступа к списку названий всех искусств (новое в версии 4.2 )
• Примечание 2: используйте NON_ASCII_ARTS для доступа ко всем спискам имен артов, отличных от ASCII (новое в версии 4.6 )

текст ASCII

⚠️ Некоторые шрифты не поддерживают все символы

⚠️ Начиная с версии 3. 3 добавлены шрифты, отличные от ASCII (эти шрифты несовместимы с некоторыми средами)

1. text2art

Эта функция возвращает текст ASCII как str в обычном режиме и вызывает artError в исключении.

 >>> Art = text2art ("art") # Вернуть текст ASCII (шрифт по умолчанию) и по умолчанию chr_ignore = True
>>> печать (Искусство)
              _
  __ _ _ __ | | _
 / _` || '__ || __ |
| (_ | || | | | _
 \ __, _ || _ | \ __ |
                  
                     
>>> Art = text2art ("art", font = 'block', chr_ignore = True) # Возвращает текст ASCII с блочным шрифтом
>>> печать (Искусство)


 .----------------. .----------------. .----------------.
| .--------------. || .--------------. || .--------------. |
| | __ | || | _______ | || | _________ | |
| | / \ | || | | _ __ \ | || | | _ _ | | |
| | / / \ \ | || | | | __) | | || | | _ / | | \ _ | | |
| | / ____ \ | || | | __ / | || | | | | |
| | _ / / \ \ _ | || | _ | | \ \ _ | || | _ | | _ | |
| || ____ | | ____ || || | | ____ | | ___ | | || | | _____ | | |
| | | || | | || | | |
| '--------------' || '--------------' || '--------------' |
 '----------------' '----------------' '------------- --- '

>>> Art = text2art ("test", "random") # режим случайного шрифта
>>> печать (Искусство)
 | |
~ | ~ / ~ / (~~ | ~
 | \ / __) |
           
>>> Art = text2art ("test", "rand") # режим случайного шрифта
>>> печать (Искусство)
___ ____ ____ ___
 | | ___ [__ |
 | | ___ ___] |

>>> print (text2art ('' 'Lorem
ipsum
dolor '' ', font = "small")) # Многострочная печать
 _
| | ___ _ _ ___ _ __
| | __ / _ \ | '_ | / -_) | '\
| ____ | \ ___ / | _ | \ ___ || _ | _ | _ |
                              
 _
(_) _ __ ___ _ _ _ __
| || '_ \ (_- <| || ||' \
| _ || . __ // __ / \ _, _ || _ | _ | _ |
   | _ |
    _ _
 __ | | ___ | | ___ _ _
/ _` | / _ \ | | / _ \ | '_ |
\ __, _ | \ ___ / | _ | \ ___ / | _ |
                        

>>> print (text2art ("test", "white_bubble")) # Пример шрифта, отличного от ASCII
Ⓣⓔⓢⓣ
>>> text2art ("art", font = "fancy5", decoration = "barcode1") # в версии 4.6 добавлен параметр оформления.
'▌│█║▌║▌║ ᏗᏒᏖ ║▌║▌║█│▌'
>>> text2art ("se سسس", font = DEFAULT_FONT, chr_ignore = False) # вызываем artError в исключении
Отслеживание (последний вызов последний):
        ...
art.art.artError: س недействителен.
  
 

2. tprint

Эта функция печатает текст ASCII в обычном режиме (возвращает None) и вызывает artError в исключении.

 >>> tprint ("art") # печатать текст ASCII (шрифт по умолчанию)
              _
  __ _ _ __ | | _
 / _` || '__ || __ |
| (_ | || | | | _
 \ __, _ || _ | \ __ |
                  

>>> tprint ("art", font = "block", chr_ignore = True) # печатать текст ASCII (блочный шрифт)

 . ----------------. .----------------..----------------.
| .--------------. || .--------------. || .--------------. |
| | __ | || | _______ | || | _________ | |
| | / \ | || | | _ __ \ | || | | _ _ | | |
| | / / \ \ | || | | | __) | | || | | _ / | | \ _ | | |
| | / ____ \ | || | | __ / | || | | | | |
| | _ / / \ \ _ | || | _ | | \ \ _ | || | _ | | _ | |
| || ____ | | ____ || || | | ____ | | ___ | | || | | _____ | | |
| | | || | | || | | |
| '--------------' || '--------------' || '--------------' |
 '----------------' '----------------' '------------- --- '

>>> tprint ('test سس') # chr_ignore flag == True (по умолчанию)
 _ _
| | _ ___ ___ | | _
| __ | / _ \ / __ || __ |
| | _ | __ / \ __ \ | | _
 \ __ | \ ___ || ___ / \ __ |
                     
>>> tprint ("test", "random") # режим случайного шрифта
 | |
~ | ~ / ~ / (~~ | ~
 | \ / __) |
           
>>> tprint ("test", "rand") # режим случайного шрифта
___ ____ ____ ___
 | | ___ [__ |
 | | ___ ___] |
                  

>>> tprint ('test سس', chr_ignore = False) # вызывать artError в исключении
Отслеживание (последний вызов последний):
       . ..
art.art.artError: س недействителен.
>>> tprint ('' 'Лорем
ipsum
dolor '' ', font = "cybermedium") # Многострочная печать
_ ____ ____ ____ _ _
| | | | __ / | ___ | \ / |
| ___ | __ | | \ | ___ | |
                            
_ ___ ____ _ _ _ _
| | __] [__ | | | \ / |
| | ___] | __ | | |
                         
___ ____ _ ____ ____
| \ | | | | | | __ /
| __ / | __ | | ___ | __ | | \

>>> tprint ("art", font = "fancy5", decoration = "barcode1") # в Версии 4 добавлен параметр оформления.6
▌│█║▌║▌║ ᏗᏒᏖ ║▌║▌║█│▌
>>> tprint ("art", font = "fancy5", decoration = "random") # В версии 5.0 добавлен случайный режим оформления.
•] • · ✦º✦ · »ᏗᏒᏖ« · ✦ º✦ · • [•
 

3. цаве

Эта функция возвращает dict в нормальном режиме и режиме исключения.

 >>> Response = tsave ("art", filename = "test.txt") # сохранить текст ASCII в файле test.txt с сообщением сохранения (print_status == True), вернуть dict
Сохранено!
Имя файла: test.txt
>>> Ответ ["Сообщение"]
'OK'
>>> Response = tsave ("art", filename = "test. txt ", print_status = False) # сохранить текст ASCII в файле test.txt без сохранения сообщения (print_status == False)
>>> Ответ ["Сообщение"]
'OK'
>>> Ответ ["Статус"]
Истинный
>>> tsave (22, font = DEFAULT_FONT, filename = "art", chr_ignore = True, print_status = True)
{'Status': False, 'Message': "объект 'int' не имеет атрибута 'split'"}
>>> Response = tsave ("art", filename = "test.txt", overwrite = True) # в версии 4.0 добавлен параметр перезаписи
Сохранено!
Имя файла: test.txt
>>> Response = tsave ("art", filename = "test.txt ", decoration =" barcode1 ") # в версии 4.6 добавлен параметр оформления
Сохранено!
Имя файла: test.txt
                        
 

• Примечание 1: используйте FONT_NAMES для доступа ко всем спискам имен шрифтов (новое в версии 4.2 )
• Примечание 2: используйте NON_ASCII_FONTS для доступа ко всем спискам имен шрифтов, отличных от ASCII (новое в версии 4.4 )

Украшение

⚠️ Некоторые среды не поддерживают все декорации

1.

декор

Эта функция возвращает оформление как str в обычном режиме и вызывает artError в исключении.

 >>> декор ("штрих-код1")
'▌│█║▌║▌║'
>>> decor ("barcode1", reverse = True)
'█│▌'
>>> decor ("barcode1") + text2art ("art", font = "fancy42") + decor ("barcode1", reverse = True)
'▌│█║▌║▌║ ąяţ ║▌║▌║█│▌'
>>> decor ("barcode1", both = True) # оба параметра добавлены в Версию 5.0
['▌│█║▌║▌║', '█│▌']
>>> decor ("random", both = True) # в версии 5.0 добавлен случайный режим
['｢(◔ω◔「) 三', '三三三 ʅ (； ◔౪◔) ʃ']
>>> decor ("rand", both = True) # в Версии 5 добавлен случайный режим.0
['‹-… · ´` ·… -›', '‹-… · ´` ·… -›']
>>> декор (Нет)
Отслеживание (последний вызов последний):
...
art.art.artError: Тип украшения должен быть str.
 

• Примечание: используйте DECORATION_NAMES для доступа ко всему списку имен украшений (новое в версии 4.6 )

Режимы шрифта

Эти режимы доступны для text2art , tprint и tsave .

1. Название шрифта

⚠️ Некоторые шрифты не поддерживают все символы

 >>> tprint ("art", font = "block", chr_ignore = True)

 .----------------. .----------------. .----------------.
| .--------------. || .--------------. || .--------------. |
| | __ | || | _______ | || | _________ | |
| | / \ | || | | _ __ \ | || | | _ _ | | |
| | / / \ \ | || | | | __) | | || | | _ / | | \ _ | | |
| | / ____ \ | || | | __ / | || | | | | |
| | _ / / \ \ _ | || | _ | | \ \ _ | || | _ | | _ | |
| || ____ | | ____ || || | | ____ | | ___ | | || | | _____ | | |
| | | || | | || | | |
| '--------------' || '--------------' || '--------------' |
 '----------------' '----------------' '------------- --- '

>>> tprint ("арт", "белый_ пузырь")
Ⓐⓡⓣ
 

2.Случайный

Случайный выбор из всех шрифтов.

Ключевые слова: случайный , рандом и рандом

 >>> tprint ("test", font = "random")
 | |
~ | ~ / ~ / (~~ | ~
 | \ / __) |
  
 

3.

Случайное маленькое

Случайный выбор мелкого шрифта.

Ключевые слова: rnd-small , random-small & rand-small

• Примечание: Новое в Версия 2.8

 >>> tprint ("test", font = "rnd-small")
             
_ / _ _ _ /
/ (- _) /
             
 

4.Случайная среда

Произвольный выбор средних шрифтов.

Ключевые слова: rnd-medium , random-medium & rand-medium

.

• Примечание: Новое в Версия 2.8

 >>> tprint ("test", font = "rnd-medium")
                      
  ,,
 || ||
= || = _-_ _-_, = || =
 || || \\ || _. ||
 || || / ~ || ||
 \\, \\, /, -_- \\,
                      
                      
 

5.Случайный большой

Произвольный выбор из крупных шрифтов.

Ключевые слова: rnd-large , random-large & rand-large

• Примечание: Новое в Версия 2. 8

 >>> tprint ("test", font = "rnd-large")
                                                                    
8888888 8888888888 8 8888888888 d888888o. 8888888 8888888888
      8 8888 8 8888 .`8888: '88. 8 8888
      8 8888 8 8888 8.`8888. Y8 8 8888
      8 8888 8 8888 `8.`8888. 8 8888
      8 8888 8 888888888888 `8.`8888. 8 8888
      8 8888 8 8888 `8.`8888. 8 8888
      8 8888 8 8888 `8.`8888. 8 8888
      8 8888 8 8888 8b `8.`8888. 8 8888
      8 8888 8 8888 `8b. ; 8.`8888 8 8888
      8 8888 8 888888888888 `Y8888P, 88P '8 8888
 

6.Случайный xlarge

Произвольный выбор из шрифтов xlarge.

Ключевые слова: rnd-xlarge , random-xlarge и rand-xlarge

• Примечание: Новое в Версия 2.8

 >>> tprint ("test", "rnd-xlarge")
      _____ _____ _____ _____
     / \ \ / \ \ / \ \ / \ \
    / :: \ \ / :: \ \ / :: \ \ / :: \ \
    \ ::: \ \ / :::: \ \ / :::: \ \ \ ::: \ \
     \ ::: \ \ / :::::: \ \ / :::::: \ \ \ ::: \ \
      \ ::: \ \ / ::: / \ ::: \ \ / ::: / \ ::: \ \ \ ::: \ \
       \ ::: \ \ / ::: / __ \ ::: \ \ / ::: / __ \ ::: \ \ \ ::: \ \
       / :::: \ \ / :::: \ \ ::: \ \ \ ::: \ \ ::: \ \ / :::: \ \
      / :::::: \ \ / :::::: \ \ ::: \ \ ___ \ ::: \ \ ::: \ \ / :::::: \ \
     / ::: / \ ::: \ \ / ::: / \ ::: \ \ ::: \ \ / \ \ ::: \ \ ::: \ \ / ::: / \ ::: \ \
    / ::: / \ ::: \ ____ \ / ::: / __ \ ::: \ \ ::: \ ____ \ / :: \ \ ::: \ \ ::: \ ____ \ / ::: / \ ::: \ ____ \
   / ::: / \ :: / / \ ::: \ \ ::: \ \ :: / / \ ::: \ \ ::: \ \ :: / / / ::: / \ :: / /
  / ::: / / \ / ____ / \ ::: \ \ ::: \ \ / ____ / \ ::: \ \ ::: \ \ / ____ / / ::: / / \ / ____ /
 / ::: / / \ ::: \ \ ::: \ \ \ ::: \ \ ::: \ \ / ::: / /
/ ::: / / \ ::: \ \ ::: \ ____ \ \ ::: \ \ ::: \ ____ \ / ::: / /
\ :: / / \ ::: \ \ :: / / \ ::: \ / ::: / / \ :: / /
 \ / ____ / \ ::: \ \ / ____ / \ ::: \ / ::: / / \ / ____ /
                           \ ::: \ \ \ :::::: / /
                            \ ::: \ ____ \ \ :::: / /
                             \ :: / / \ :: / /
                              \ / ____ / \ / ____ /
                                                                                            
 

7.

Волшебник

Этот режим учитывает длину вводимого текста для выбора шрифта

☑️ Гарантированная поддержка 95 символов ASCII

Ключевые слова: волшебник , волшебник и магия

• Примечание: Новое в Версия 2.9

 >>> tprint («1», «волшебник»)
    88
  , d88
888888
    88
    88
    88
    88
    88
    88
    88
       
            

>>> tprint ("1" * 5, "волшебник")
d88 d88 d88 d88 d88
 88 88 88 88 88
 88 88 88 88 88
 88 88 88 88 88
 88 88 88 88 88
d88P d88P d88P d88P d88P
                         
                         

>>> tprint ("1" * 15, "волшебник")
                                             
                                             
 # # # # # # # # # # # # # # #
## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
 # # # # # # # # # # # # # # #
 # # # # # # # # # # # # # # #
 # # # # # # # # # # # # # # #
## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
                                             
                                             
 

8.

Случайный не-ASCII

Произвольный выбор из шрифтов, отличных от ASCII.

Ключевые слова: random-na , rand-na & rnd-na

• Примечание: Новое в Версия 3.4

 >>> tprint ("test", "random-na")
₮ Ɇ ₴ ₮
>>> tprint ("test", "random-na")
ʇsǝʇ
 

9. Смешайте не-ASCII

Случайное смешивание шрифтов, отличных от ASCII.

Ключевые слова: смесь

• Примечание: Новое в версии 3.7

 >>> tprint ("тест", "микс")
† Ɛ †
>>> tprint ("тест", "микс")
t Ꮛ št
>>> tprint ("тест", "микс")
꓄ є ร ꓄
 

⚠️ Шрифты, отличные от ASCII, доступны только в Имя шрифта , Произвольно не-ASCII и Mix режимы

Допуск опечаток

Расстояние Левенштейна, использованное в этом проекте. ( Версия > 0.9)

 >>> aprint ("happy") # правильно -> aprint ("happy"), error <| artname | / 2
 ۜ \ (סּ ں סּ َ`) / ۜ
>>> Art = art ("birds2222222", number = 1) # правильно -> Art = art ("birds", number = 1), error> = | artname | / 2
Отслеживание (последний вызов последний):
. ..
art.art.artError: Недействительное название произведения искусства.
>>> aprint ("happyi231") # правильно -> aprint ("happy"), error <| artname | / 2
⎦˚◡˚⎣
>>> aprint ("happyi2312344") # правильно -> aprint ("happy"), error> = | artname | / 2
Отслеживание (последний вызов последний):
...
art.art.artError: Недействительное название произведения искусства.
>>> Art = text2art ("test", font = "black") # правильно -> Art = text2art ("test", font = "block")
>>> печать (Искусство)

 .----------------. .----------------. .----------------. .----------------.| .--------------. || .--------------. || .--------------. || .--------------. |
| | _________ | || | _________ | || | _______ | || | _________ | |
| | | _ _ | | || | | _ ___ | | || | / ___ | | || | | _ _ | | |
| | | _ / | | \ _ | | || | | | _ \ _ | | || | | (__ \ _ | | || | | _ / | | \ _ | | |
| | | | | || | | _ | _ | || | '.___ `-. | || | | | | |
| | _ | | _ | || | _ | | ___ / | | || | | `\ ____) | | || | _ | | _ | |
| | | _____ | | || | | _________ | | || | | _______. '| || | | _____ | | |
| | | || | | || | | || | | |
| '--------------' || '--------------' || '--------------' || '--------------' |
 '----------------' '----------------' '------------- --- '' ---------------- '

>>> tprint ("test", font = "cybermedum") # правильно -> tprint ("test", font = "cybermedium")
___ ____ ____ ___
 | | ___ [__ |
 | | ___ ___] |
                  
   
 

Установить значения по умолчанию

set_default функция добавлена ​​в версии 2.2 , чтобы изменить значения по умолчанию.

 >>> справка (set_default)
Справка по функции set_default в модуле art.art:

set_default (font = 'standard', chr_ignore = True, filename = 'art', print_status = True, overwrite = False, decoration = None)
    Измените значения text2art, tprint и tsave по умолчанию.
    
    : param font: шрифт ввода
    : type font: str
    : param chr_ignore: игнорировать неподдерживаемый символ
    : введите chr_ignore: bool
    : param filename: имя выходного файла (только tsave)
    : type filename: str
    : param print_status: сохранить флаг печати сообщения (только tsave)
    : введите print_status: bool
    : param overwrite: перезаписать сохраненный файл, если true (только tsave)
    : type overwrite: bool
    : param decoration: входное оформление
    : тип украшения: ул. 
    : return: Нет

>>> tprint ("тест")
 _ _
| | _ ___ ___ | | _
| __ | / _ \ / __ || __ |
| | _ | __ / \ __ \ | | _
 \ __ | \ ___ || ___ / \ __ |
                     

>>> set_default (font = "italic")
>>> tprint ("тест")
             
_ / _ _ _ /
/ (- _) /
             
 

Тестирование

• Только шрифты и рисунки ASCII:

  python -m художественный тест
  

• Все шрифты, украшения и украшения:

  python -m art test2
  

CLI

• Список искусств: python -m art list или python -m art arts
• Список шрифтов: python -m art fonts
• Текст: python -m art text yourtext fontname (необязательно)
• Art: python -m art shape art_name или python -m art art art_name
• Сохранить: python -m art save yourtext fontname (необязательно)
• Все: python -m art all yourtext

Telegram бот

Просто отправьте текст одному из этих ботов. 👇👇👇👇

Попробуйте ART в своем браузере

1. ART можно использовать онлайн в интерактивных блокнотах Jupyter через службу Binder! Попробуйте прямо сейчас! :

• Открыть FontList.ipynb , ArtList.ipynb и DecorList.ipynb
• Отредактируйте и выполните каждую часть нот, шаг за шагом с верхней панели с помощью кнопки запуска

1. ART также можно использовать онлайн в ascii-генераторе.site, сайт Django от hermanTenuki

Запись экрана

Запись экрана

Проблемы и отчеты об ошибках

Просто укажите проблему и опишите ее. Я проверю как можно скорее!
или отправьте электронное письмо на адрес [email protected].

• Пожалуйста, заполните шаблон проблемы

Зависимости

Лицензия

Номер ссылки

1. Фиглетка
2. 1 линия Art
3. Текст в формате ASCII
4. Генератор ASCII
5. Аски
6. Flipyourtext
7. YayText
8. Coolletters
9. Шрифты Instagram
10. Cool Symbol
11. ASCII Moji
12. ОХЛАЖДЕНИЕ УЛЫБКИ
13. SPREZZ
14. Textart4u
15. Chat4o
16. Findwebapp
17. Hubpages
18. ASCII-ART
19. Сообщения
20. Веб-инструменты
21. ASCII-эмодзи
22. шрифтов Instagram2
23. Emotiworld

Пожертвовать нашему проекту

Биткойн:

12Xm1qL4MXYWiY9sRMoa3VpfTfw6su3vNq

Payping (для граждан Ирана)

Все заметные изменения в этом проекте будут задокументированы в этом файле.

Формат основан на ведении журнала изменений.
и этот проект придерживается семантического управления версиями.

5.1 — 30.11.2020

Добавлено

• 15 новых шрифтов
  1. фантазии 120
  2. фантазия121
  3. фантазия122
  4. фантазии123
  5. фантазия124
  6. фантазия125
  7. фантазии126
  8. фантазия127
  9. фантазия128
  10. фантазии129
  11. бутон
  12. бутон 2
  13. контакт1
  14. пин2
  15. знак
• 45 новое искусство
  1. удивлен4
  2. удивлен5
  3. удивлен6
  4. удивлен7
  5. удивлен8
  6. удивлен9
  7. удивлен10
  8. удивлен11
  9. удивлен12
  10. удивлен13
  11. удивлен14
  12. удивлен15
  13. удивлен16
  14. удивлен17
  15. удивлен 18
  16. удивлен19
  17. удивлен20
  18. путать 3
  19. путать 4
  20. путать 5
  21. смущает 6
  22. путать7
  23. смущает 8
  24. смущенный 9
  25. смущает 10
  26. стол flip2
  27. стол flip3
  28. откидной стол
  29. откидной стол 5
  30. откидной стол
  31. откидной стол
  32. стол flip8
  33. стол откидной9
  34. стол flip10
  35. медведь2
  36. паук 4
  37. cat4
  38. плавать
  39. плавать 2
  40. плавать3
  41. зевая
  42. сиськи2
  43. самолет3
  44. пистолет4
  45. cthulhu2

5.

0-2020-11-16

Добавлено

• 5 новых шрифтов
  1. шаша
  2. фантазии116
  3. фантазия117
  4. фантазии118
  5. фантазии119
• 60 новых арт
  1. привет2
  2. dunno2
  3. dunno3
  4. не знаю4
  5. dunno5
  6. счастливый6
  7. счастливый7
  8. счастливый8
  9. счастливый9
  10. счастливый10
  11. счастливый11
  12. счастливый12
  13. счастливый13
  14. счастливый14
  15. счастливый15
  16. счастливый16
  17. счастливый17
  18. счастливый18
  19. счастлив19
  20. счастливый20
  21. счастливый21
  22. счастливый22
  23. счастливый23
  24. счастливый24
  25. счастливый25
  26. счастливый26
  27. счастливый27
  28. любовь4
  29. поцелуй 2
  30. поцелуй 3
  31. поцелуи2
  32. поцелуи3
  33. поцелуи 4
  34. поцелуи5
  35. поцелуи6
  36. милое лицо2
  37. милое лицо3
  38. милое лицо4
  39. милое лицо5
  40. милое лицо6
  41. милое лицо7
  42. милое лицо8
  43. милое лицо9
  44. расстроен
  45. пистолеты4
  46. пистолеты5
  47. безумный
  48. mad2
  49. mad3
  50. mad4
  51. mad5
  52. mad6
  53. mad7
  54. mad8
  55. mad9
  56. mad10
  57. палец3
  58. палец4
  59. сад5
  60. сад6

Изменено

• случайный режим добавлен в декор Функция
• оба параметра добавлены в декор Функция
• арт функция изменена
• Indirect_font функция изменена

4.

9 — 2020-10-16

Добавлено

• 10 новых шрифтов
  1. фокси
  2. фантазии109
  3. фантазии110
  4. фантазии111
  5. фантазии112
  6. фантазии113
  7. фантазии114
  8. фантазия115
  9. шек
  10. фари

Изменено

• font_wizard.py скрипт обновлен
• README.md изменено

4.8 — 2020-09-16

Добавлено

• 96 новое искусство
  1. злые птицы
  2. сердитое лицо2
  3. злой тролль
  4. по какой цене
  5. барф
  6. купаясь в славе
  7. медведь GTFO
  8. медведь на корточках
  9. бокс
  10. разбивка
  11. небрежный
  12. чеканка
  13. ура
  14. курица
  15. запутанная царапина
  16. сумасшедший
  17. ходоуменьшитель
  18. плачущее лицо
  19. крик тролль
  20. милое лицо
  21. танец2
  22. танцы
  23. Боже мой, почему
  24. коварная улыбка
  25. не согласен
  26. сбит с толку
  27. не нравится1
  28. не нравится2
  29. ты вообще поднимаешь братан?
  30. двойной флип
  31. эмо танец
  32. возбуждено
  33. экзорцизм
  34. закатка глаз
  35. чувствовать себя задорно
  36. фидо
  37. бой
  38. кулачный бой
  39. флип друг
  40. улет
  41. летающий
  42. ебать тебя 2
  43. счастливое лицо
  44. счастливое объятие
  45. автостоп
  46. hugger
  47. я обнимаю
  48. ранены
  49. невинное лицо
  50. морда японского льва
  51. осуждающий
  52. судейство
  53. целоваться
  54. эмоция котенка
  55. наушники для прослушивания
  56. смотрит вниз
  57. любовь3
  58. мяу
  59. без поддержки
  60. опера
  61. гляделки
  62. красивые глаза
  63. поставить стол обратно
  64. отдыхаю глазами
  65. робот3
  66. работает
  67. грустный и сбитый с толку
  68. грустный и плачущий
  69. грустное лицо
  70. доволен
  71. уплотнение
  72. морда акулы
  73. застенчивая
  74. сонный
  75. смотрит
  76. чужая опасность
  77. стойка
  78. потрясающие оттенки
  79. удивлен2
  80. принимает дамп
  81. tgif
  82. вещей, которые нельзя не увидеть
  83. прибраться
  84. усталый
  85. обидчивый филли
  86. отключение
  87. троллинг
  88. волна танец
  89. Whling
  90. винни пух
  91. выигрыш
  92. мастер 2
  93. волновался
  94. юн
  95. зомби 2
  96. районный

Изменено

• удивлено2 Однострочное изображение переименовано в удивлено3
• art_decor_check. py скрипт обновлен
• font_check.py скрипт обновлен
• font_wizard.py скрипт обновлен

4,7 — 2020-05-20

Добавлено

• art_decor_check.py файл
• Приветствие действий GitHub
• 185 новых украшений
  1. сердитый1
  2. стрелка 1
  3. стрелка 2
  4. стрелка 3
  5. стрелка 4
  6. стрелка 5
  7. стрелка 6
  8. стрелка 7
  9. стрелка 8
  10. arrow_wave1
  11. arrow_wave2
  12. мяч1
  13. мяч2
  14. мяч3
  15. базар1
  16. блок 1
  17. блок2
  18. лук 1
  19. пузырь
  20. cat1
  21. cat2
  22. cat3
  23. ячейка 1
  24. путать 1
  25. путать 2
  26. крест1
  27. депрессия
  28. диамон3
  29. алмаз1
  30. алмаз2
  31. Египет1
  32. эмоций1
  33. фантазии1
  34. фантазии2
  35. фантазии3
  36. фантазии4
  37. фантазии5
  38. фантазии6
  39. фантазии7
  40. фантазии8
  41. фантазии9
  42. фантазии10
  43. фантазии11
  44. фантазии12
  45. фантазии13
  46. фантазии14
  47. фантазии15
  48. фантазии16
  49. фантазии17
  50. фантазии18
  51. фантазии19
  52. фантазии20
  53. фантазия 21
  54. фантазии22
  55. фантазии23
  56. фантазии24
  57. фантазии25
  58. фантазии26
  59. фантазии27
  60. фантазии28
  61. фантазии29
  62. фантазии 30
  63. фантазии31
  64. фантазии32
  65. фантазии33
  66. фантазии34
  67. фантазии35
  68. фантазии36
  69. фантазия37
  70. фантазии38
  71. фантазии39
  72. фантазии40
  73. фантазии41
  74. фантазии42
  75. фантазии 43
  76. фантазия44
  77. фантазии45
  78. фантазии46
  79. фантазия47
  80. фантазии48
  81. фантазии49
  82. фантазии50
  83. фантазии51
  84. фантазии52
  85. фантазии53
  86. фантазии54
  87. фантазии55
  88. фантазии56
  89. фантазия57
  90. фантазии58
  91. фантазии59
  92. фантазии60
  93. фантазии61
  94. фантазии62
  95. фантазии63
  96. фантазии64
  97. фантазии65
  98. фантазии66
  99. фантазии67
  100. фантазии68
  101. фантазия69
  102. фантазии70
  103. фантазии71
  104. фантазии72
  105. фантазии73
  106. фантазии74
  107. фантазия75
  108. фантазии76
  109. фантазии77
  110. фантазии78
  111. fancy79
  112. фантазии80
  113. фантазии81
  114. фантазии82
  115. фантазии83
  116. фантазии84
  117. фантазии85
  118. фантазии86
  119. пламя 1
  120. цветок1
  121. еда1
  122. еда2
  123. ха-ха
  124. счастливый1
  125. happy_new_year
  126. Гавайи 1
  127. Гавайи 2
  128. сердце1
  129. сердце2
  130. сердце3
  131. сердце4
  132. сердце5
  133. сердце6
  134. сердце7
  135. сердце8
  136. сердце9
  137. строка 1
  138. строка 2
  139. строка 3
  140. строка 4
  141. love_music
  142. ракета1
  143. гора1
  144. гора2
  145. гора3
  146. музыка1
  147. музыка2
  148. музыка3
  149. карандаш1
  150. покер1
  151. головоломка 1
  152. головоломка 2
  153. головоломка3
  154. sad2
  155. sad3
  156. сад4
  157. смайл 1
  158. снег1
  159. снег2
  160. звезд3
  161. звезд4
  162. звезд5
  163. звезд6
  164. звезд7
  165. звезд 8
  166. звезд9
  167. звезд10
  168. звезд11
  169. звезд12
  170. звезд13
  171. звезд14
  172. звезд15
  173. звезд16
  174. звезд17
  175. храм1
  176. название1
  177. дерево1
  178. стена1
  179. волна3
  180. волна4
  181. волна5
  182. волна6
  183. волна7
  184. волна8
  185. волна9

Изменено

• текст параметр удален из art и aprint functions
• README. md модифицированный
• CONTRIBUTING.md изменено
• Обновлены примеры MATLAB
• kitty2 Однострочная графика переименована в kitty

Удалено

• 5 двусторонних однострочных рисунков
  1. люблю тебя
  2. сообщение1
  3. сообщение2
  4. музыкальный
  5. текстовое оформление
• 12 дубликатов рисунка в одну линию
  1. собака
  2. человек
  3. разное
  4. 100 $
  5. червь2
  6. звезд в моих глазах
  7. цепной меч
  8. задира
  9. пришельцев
  10. этот парень
  11. котенок1
  12. Дон Фуллер

4.6-2020-03-30

Добавлено

• NON_ASCII_ARTS список
• decor_dic.py файл
• codecov.yml файл
• декор функция
• decor_list функция
• Блокнот DecorList. ipynb
• 10 новых украшений
  1. штрих-код1
  2. чемпион 1
  3. шахматы1
  4. повезло1
  5. грустный 1
  6. футбол1
  7. звезд1
  8. звезд2
  9. волна1
  10. волна2
• 20 новых шрифтов
  1. мошенник
  2. зачеркнутый
  3. драко
  4. кельтский
  5. мода
  6. кудрявый
  7. русский
  8. писем
  9. вихрь
  10. пунктирная
  11. в скобках
  12. странно
  13. волнистый
  14. мутный
  15. hyves
  16. awcute
  17. катушка
  18. коптский 1
  19. коптский2
  20. фантазии108

Изменено

• ПРОЧИТАТЬ.md модифицированный
• CONTRIBUTING.md изменено
• Обновлены примеры MATLAB
• setup.py изменено
• покрытие зависимость перенесена на extras_require
• Модифицированная испытательная система
• случайный режим изменен
• test параметр удален из font_list function
• Режим Режим добавлен в font_list и art_list функции
• украшение добавлен параметр text2art , tprint и tsave функции
• \ n Ошибка поддержки исправлена ​​
• Исправлена ​​ошибка функции tsave в Windows

Удалено

4.

5 — 2020-01-29

Добавлено

• 35 новых шрифтов
  1. гладкая 2
  2. гладкий3
  3. перевозчик1
  4. перевозчик2
  5. милый1
  6. милый2
  7. милый3
  8. cjk
  9. малаялам
  10. лилия
  11. карлик
  12. отлично
  13. lopioo
  14. капризный
  15. фантазии87
  16. фантазии88
  17. фантазии89
  18. фантазии90
  19. фантазии91
  20. фантазии92
  21. фантазии 93
  22. фантазии94
  23. фантазии95
  24. фантазии96
  25. фантазии97
  26. фантазии98
  27. фантазия99
  28. фантазии100
  29. фантазия101
  30. фантазия102
  31. фантазии103
  32. фантазии104
  33. фантазии105
  34. фантазии106
  35. фантазии107
• 43 новая однострочная графика
  1. рыб6
  2. Лох-несское чудовище
  3. мышь 5
  4. мышь6
  5. мышь7
  6. овец
  7. пирог бой
  8. роза5
  9. роза6
  10. роза7
  11. обеспокоены
  12. счастливый4
  13. счастливый5
  14. кофе2
  15. кофе3
  16. кофе4
  17. наушники3
  18. ковролин
  19. бесконечность
  20. компьютерная мышь
  21. вулкан1
  22. вулкан2
  23. вулкан3
  24. волнистая спираль
  25. пальма
  26. промежность выстрел
  27. влагалище
  28. истребитель-невидимка
  29. палатка 1
  30. палатка2
  31. линии электропередачи
  32. пень
  33. молоток
  34. стрелка 2
  35. меч10
  36. скелет рыбы2
  37. вилка
  38. труба
  39. мертвец
  40. мертвая девочка
  41. мертвый ребенок
  42. чувак в очках1
  43. чувак в очках2

Изменено

• ПРОЧИТАТЬ. md модифицированный
• INSTALL.md модифицированный
• кофе Однострочная графика переименована в coffee1
• стрелка Однострочная графика переименована в arrow1
• скелет рыбы 1-линейное изображение переименовано в скелет рыбы 1

4.4 — 26.12.2019

Добавлено

• 68 новое однострочное
  1. улыбка
  2. toungue out1
  3. toungue out2
  4. плохие волосы1
  5. плохие волосы2
  6. шуб
  7. кричать
  8. полный рот
  9. ругаться
  10. готов плакать
  11. плачет2
  12. бурение1
  13. бурение2
  14. большой поцелуй
  15. французский поцелуй
  16. подмигнуть
  17. большая улыбка
  18. ухмылка
  19. путать 1
  20. путать 2
  21. поджимающие губы
  22. в шоке2
  23. очень грустно
  24. бейсбольный болельщик
  25. ангел 2
  26. действительно сумасшедший
  27. облизывание губ
  28. зубьев опоры
  29. удивлен1
  30. инопланетянин
  31. солнцезащитные очки2
  32. дон король
  33. дьявольская улыбка
  34. дьявольская ухмылка
  35. клоунада
  36. багз кролик
  37. котенок2
  38. скелет рыбы
  39. снеговик2
  40. зефир
  41. ботаник
  42. мышь 4
  43. пистолетов3
  44. рок на2
  45. любовь в моих глазах2
  46. любовь в моих глазах3
  47. sad3
  48. сад4
  49. наушники2
  50. сигарета 1
  51. паук 3
  52. штрих-код2
  53. эквалайзер
  54. бумбокс2
  55. удивлен2
  56. игральные карты
  57. игральные карты сердечки
  58. игральные карты алмазы
  59. игральные карты пики
  60. игральные карты клубов
  61. лопата жирная
  62. жирный шрифт
  63. алмазный полужирный
  64. клуб жирный
  65. лопата обычная
  66. сердце обычное
  67. бриллиант обычный
  68. клуб обычный
• Примеры MATLAB

Изменено

• Двустороннее искусство устарело
• плачет Однострочная графика переименована в плач1
• в шоке Однострочная графика переименована в в шоке 1
• angel Однострочная графика переименована в angel1
• солнцезащитные очки 1-line art переименованы в солнцезащитные очки 1
• kitty Однострочная графика переименована в kitty1
• снеговик 1 линия переименована в снеговик 1
• штрих-код Однострочная графика переименована в штрих-код1
• сигарета 1-строчная переименована в сигарета 3
• сигарета 1-строчная переименована в сигарета2
• наушники 1-line art переименованы в headphone1
• камень на 1-линейный арт переименован в камень на 1
• Бумбокс Однострочное изображение переименовано в Бумбокс1
• Любовь в моих глазах Однострочная графика переименована в Любовь в моих глазах1
• ДОГОВОР. md модифицированный
• TEST_FILTERED_FONTS переименован в NON_ASCII_FONTS
• RANDOM_FILTERED_FONTS и NON_ASCII_FONTS списки оптимизированы
• README.md изменено
• appveyor.yml модифицированный
• INSTALL.md модифицированный
• мастер режим модифицирован

4.3 — 05.12.2019

Добавлено

• 35 новый арт.
  1. чашка 1
  2. чашка2
  3. пистолет2
  4. пистолет3
  5. рыб4
  6. рыб 5
  7. рыб 5
  8. меч6
  9. меч7
  10. меч8
  11. меч9
  12. нож2
  13. штрих-код
  14. загрузка1
  15. загрузка3
  16. загрузка4
  17. загрузка5
  18. загрузка6
  19. бат2
  20. пластырь
  21. мышь2
  22. мышь3
  23. cat3
  24. игла 2
  25. роза4
  26. электрокардиограмма1
  27. электрокардиограмма2
  28. электрокардиограмма3
  29. электрокардиограмма4
  30. улитка2
  31. американские деньги2
  32. американских денег3
  33. американских денег4
  34. американских денег5
  35. кассета 2
• 10 новых шрифтов
  1. Сара
  2. хиппи
  3. миньон
  4. greek_legends
  5. funky_fresh
  6. Атлантик
  7. foreign_friends
  8. native_lands
  9. sunday_cuddle
  10. chinese_mafia

Изменено

• пистолет Однострочный арт переименован в gun1
• нож Однострочный арт переименован в нож 1
• загрузка Однострочная графика переименована в loading2
• bat Однострочная графика переименована в bat1
• мышь Однострочная графика переименована в mouse1
• Игла Однострочная графика переименована в Игла 2
• улитка Однострочная графика переименована в snail1
• американские деньги Однострочная графика переименована в американские деньги 1
• кассета 1-строчная графика переименована в кассета 1
• Модифицированная испытательная система

4.

2-2019-10-30

Добавлено

• 14 новых шрифтов
  1. smallcaps3
  2. фрактур2
  3. bold_fraktur
  4. полужирный шрифт
  5. почерк1
  6. почерк2
  7. русифи
  8. моноширинный
  9. грязный2
  10. рыцарь2
  11. h5k3r
  12. тонкий3
  13. крошечный2
  14. upside_down
• FONT_NAMES переменная
• ART_NAMES переменная

Изменено

4.1 — 26.09.2019

Добавлено

• 20 новых шрифтов
  1. фантазии75
  2. фантазии76
  3. фантазии77
  4. фантазии78
  5. любовь1
  6. fancy79
  7. фантазии80
  8. фантазии81
  9. фантазии82
  10. фантазии83
  11. фантазии84
  12. фантазии85
  13. фантазии86
  14. контурная3
  15. контурная4
  16. любовь2
  17. черный_квадрат
  18. белый_квадрат
  19. черный_ пузырь
  20. паранормальные явления
• get_font_dic функция

Изменено

• font_check. ру модифицированный
• font_wizard.py изменено
• CONTRIBUTING.md изменено

4.0 — 12.09.2019

Добавлено

• install.sh
• autopep8.sh
• 21 новый шрифт
  1. фантазии56
  2. фантазия57
  3. фантазии58
  4. фантазии59
  5. фантазии60
  6. фантазии61
  7. фантазии62
  8. фантазии63
  9. fanyc64
  10. фантазии65
  11. фантазии66
  12. фантазии67
  13. фантазии68
  14. фантазия69
  15. fanyc70
  16. фантазии71
  17. фантазии72
  18. фантазии73
  19. фантазии74
  20. контурная 1
  21. контурная 2

Изменено

• тест.sh перенесен в папку .travis
• font_wizard.py обновлено
• font_check.py обновлено
• tsave исправлены ошибки функции
• aprint и tprint функции изменены
• Модифицированная испытательная система
• перезаписать параметр добавлен в функции tsave и set_default
• README. md изменено
• ДОГОВОР.md модифицированный

3.9 — 21.08.2019

Добавлено

• __version__ переменная
• font_wizard.py
• 15 новых шрифтов
  1. фантазии41
  2. фантазии42
  3. фантазии 43
  4. фантазия44
  5. фантазии45
  6. фантазии46
  7. фантазия47
  8. фантазии48
  9. фантазии49
  10. фантазии50
  11. фантазии51
  12. фантазии52
  13. фантазии53
  14. фантазии54
  15. фантазии55

Изменено

• VERSION переменная переименована в ART_VERSION
• Некоторые шрифты перемещены в text_dic3.py
• ISSUE_TEMPLATE.md изменено
• CONTRIBUTING.md изменено

3.8 — 19.07.2019

Добавлено

• 11 новых шрифтов
  1. фантазии31
  2. фантазии32
  3. фантазии33
  4. фантазии34
  5. символов
  6. фантазии35
  7. фантазии36
  8. фантазия37
  9. фантазии38
  10. фантазии39
  11. фантазии40
• 20 новых однострочных рисунков
  1. кислота
  2. наконечник стрелы
  3. неудобно
  4. потому что
  5. черный
  6. catlenny
  7. мазок
  8. damnyou
  9. депрессия
  10. не знаю
  11. eeriemob
  12. конверт
  13. пердеть
  14. финн
  15. нахмуриться
  16. глиттер
  17. готит
  18. привет
  19. загрузка
  20. мип

Изменено

• dev-требования. txt изменено

3,7 — 24.06.2019

Добавлено

• 3 новых шрифта
  1. фантазия28
  2. фантазии29
  3. фантазии 30
• смешать режим

Изменено

• Тест дублирования добавлен в font_check.py
• README.md изменено
• fancy11 и fancy14 обновлены шрифты
• Indirect_font функция изменена

Удалено

• 9 повторяющихся шрифтов
  1. волшебный
  2. morse2
  3. fire_font-k
  4. паранормальные явления
  5. battle_s
  6. ntgreek
  7. пиков наклонная
  8. колдун
  9. нанси-улучшенный

3.6 — 2019-05-15

Добавлено

• 20 новых шрифтов
  1. фантазии 8
  2. фантазии9
  3. фантазии10
  4. фантазии11
  5. фантазии12
  6. фантазии13
  7. фантазии14
  8. фантазии15
  9. фантазии16
  10. фантазии17
  11. фантазии18
  12. фантазии19
  13. фантазии20
  14. фантазия 21
  15. фантазии22
  16. фантазии23
  17. фантазии24
  18. фантазии25
  19. фантазии26
  20. фантазии27

Изменено

3.

5 — 04.05.2019

Добавлено

• 15 новых шрифтов
  1. волшебный
  2. паранормальные явления
  3. колдун
  4. специальный
  5. грязный
  6. рыцарь
  7. тонкий2
  8. крошечный
  9. фантазии1
  10. фантазии2
  11. фантазии3
  12. фантазии4
  13. фантазии5
  14. фантазии6
  15. фантазии7

3,4 — 20.04.2019

Добавлено

• 7 новых шрифтов
  1. белый_ пузырь
  2. капс 2
  3. надстрочный
  4. индекс
  5. full_width
  6. валюта
  7. антрофобия
• text2art поддержка функции \ n
• рнд-на режим

Изменено

• tprint функция изменена
• цаве функция изменена
• README.md модифицированный
• случайный режим изменен

3.

3 — 10.04.2019

Добавлено

• 3 новых шрифта
  1. зеркало
  2. флип
  3. зеркало_флип
• 40 новых однострочных рисунков
  1. мертвые глаза
  2. сатана
  3. бомба
  4. сонный кофе
  5. высокая пятерка
  6. wtf чувак?
  7. гриб
  8. derp
  9. drwoning
  10. почти позаботились
  11. лет
  12. кофе сейчас
  13. круглый кот
  14. выжимка
  15. круглая птица
  16. hoxom
  17. кальмар
  18. человек паук
  19. наложенное заклинание
  20. джазовый музыкант
  21. мьянская кошка
  22. дай
  23. краб
  24. играет в снегу
  25. солнцезащитные очки
  26. мини пенис
  27. победа
  28. Дон Фуллер
  29. dgaf
  30. Райанс Дик
  31. ред Дик
  32. точка
  33. боится
  34. смеется
  35. энергия
  36. пьянство
  37. ошибка
  38. пенис2
  39. обмен
  40. пение2
• test2. py
• font_check.py

Изменено

• test_mode параметр добавлен в font_list функция
• все ошибка флага исправлена ​​
• __main__.py изменено
• Предупреждения и сообщения об ошибках перемещены в art_param.py
• Произвольный режим искусства изменен

3,2 — 02.04.2019

Добавлено

• 30 новых однострочных арт.
  1. пожать плечами
  2. шлейф
  3. этот парень
  4. почему
  5. медитация
  6. котенок
  7. пак человек
  8. эмо
  9. нападение акулы
  10. в шоке
  11. монокль
  12. копилка
  13. камера
  14. что ??
  15. neo
  16. ленни
  17. идет снег
  18. член
  19. волшебник
  20. Вт
  21. чу
  22. приклад
  23. Софи
  24. радость
  25. баутиста
  26. гладкая
  27. ебля
  28. половой член
  29. Вт-Вт
  30. сбой
• pydocstyle тест

Изменено

• Измененные строки документации
• Исправлена ​​ошибка в некоторых шрифтах со строчными буквами
• Изменены случайные режимы шрифта
• test_mode параметр удален из font_list функция

3.

1 — 2019-03-06

Добавлено

• 30 новых однострочных арт.
  1. роза3
  2. сигарета
  3. весло
  4. меч5
  5. легковой автомобиль
  6. ножовка
  7. каноэ
  8. паук 1
  9. пулемет
  10. блокпост
  11. пришельцев
  12. мардж симпсон
  13. гомер симпсон
  14. летучая мышь
  15. логотип супермена
  16. ДНК образец
  17. почтовый ящик
  18. нло 1
  19. нло 2
  20. паук 2
  21. американские деньги
  22. британские деньги
  23. типи
  24. сердце3
  25. ангел
  26. акула
  27. задница обычная
  28. толстая задница
  29. поцелуй меня в задницу
  30. дьявол
• 15 новых шрифтов
  1. будущее_1
  2. будущее_2
  3. future_3
  4. future_4
  5. future_5
  6. future_6
  7. future_7
  8. future_8
  9. перчатка
  10. ghost_bo
  11. grand_pr
  12. green_be
  13. аид
  14. heavy_me
  15. nfi1