В основном __str__ или str() используется для создания вывода, который удобочитаем и должен быть предназначен для конечных пользователей. С другой стороны, repr() или __repr__ в основном возвращает каноническое строковое представление объектов, которое служит для отладки и разработки, помогает программистам.

Программисты с предыдущим опытом работы с языками с методом toString склонны реализовывать __str__, а не __repr__. Если вы реализуете только один из этих специальных методов в Python, выберите __repr__.

Из книги Fluent Python Рамальо Лучано.

Вы можете получить некоторое представление об этом коде:

class Foo():
    def __repr__(self):
        return("repr")
    def __str__(self):
        return("str")

foo = Foo()
foo #repr
print(foo) #str

Каждый объект наследует __repr__ от базового класса, созданного всеми объектами.

class Person:
     pass

p=Person()

, если вы позвоните по номеру repr(p), вы получите по умолчанию:

 <__main__.Person object at 0x7fb2604f03a0>

Но если вы позвоните по телефону str(p), вы получите тот же результат. это потому, что когда __str__ не существует, Python вызывает __repr__

Давайте реализуем наш собственный __str__

class Person:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __repr__(self):
        print("__repr__ called")
        return f"Person(name='{self.name}',age={self.age})"

p=Person("ali",20)

print(p) и str(p) вернут

 __repr__ called
     Person(name='ali',age=20)

добавим __str__()

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
    def __repr__(self):
        print('__repr__ called')
        return f"Person(name='{self.name}, age=self.age')"
    
    def __str__(self):
        print('__str__ called')
        return self.name

p=Person("ali",20)

, если мы вызовем print(p) и str (p), он вызовет __str__(), поэтому он вернет

__str__ called
ali

repr(p) вернет

представитель позвонил "Человек (имя = 'ali, age = self.age')"

Давайте опустим __repr__ и просто реализуем __str__.

class Person:
def __init__(self, name, age):
    self.name = name
    self.age = age

def __str__(self):
    print('__str__ called')
    return self.name

p=Person('ali',20)

print(p) будет искать __str__ и вернет:

__str__ called
ali

ПРИМЕЧАНИЕ = если бы у нас были определены __repr__ и __str__, f'name is {p}' вызвал бы __str__

Вопрос: В чем разница между __str__() и __repr__()?

TL; DR:

ДЛИННЫЙ

Этот вопрос существует давно, и существует множество ответов, большинство из которых верны (не говоря уже о нескольких легендах сообщества Python [!]). Однако, когда дело доходит до мелочей, этот вопрос аналогичен вопросу о разнице между встроенными функциями str() и repr(). Я собираюсь описать различия своими словами (что означает, что я, возможно, вольно «заимствую» из Core Python Programming , так что, пожалуйста, простите меня).

И str(), и repr() выполняют одну и ту же базовую задачу: их цель - вернуть строковое представление объекта Python. тип строкового представления - вот что их отличает.

• str() & __str__() возвращает печатаемое строковое представление объект ... что-то удобочитаемое / для потребления человеком
• repr() & __repr__() возвращает строковое представление объекта, который является действительный объект Python , что-то, что вы можете передать в eval() или ввести в оболочку Python без получения ошибки.

Например, давайте назначим строку для x и int для y и просто покажем удобочитаемые строковые версии каждого:

>>> x, y = 'foo', 123
>>> str(x), str(y)
('foo', '123')

Можем ли мы взять то, что находится внутри кавычек в обоих случаях, и ввести их дословно в интерпретатор Python? Давайте попробуем:

>>> 123
123
>>> foo
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'foo' is not defined

Очевидно, вы можете для int, но не обязательно для str. Хотя я могу передать '123' в eval(), это не работает для 'foo':

>>> eval('123')
123
>>> eval('foo')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name 'foo' is not defined

Теперь попробуем repr(); снова выгрузите то, что в паре кавычек для каждой строки:

>>> repr(x), repr(y)
("'foo'", '123')
>>> 123
123
>>> 'foo'
'foo'

Вау, они оба работают? Это потому, что 'foo', хотя и является печатаемым строковым представлением этой строки, оно не оцениваемо, а "'foo'" можно. 123 - допустимый Python int, вызываемый либо str(), либо repr(). Что произойдет, если мы позвоним по номеру eval() с этим?

>>> eval('123')
123
>>> eval("'foo'")
'foo'

Это работает, потому что 123 и 'foo' являются допустимыми объектами Python. Еще один важный вывод: иногда оба возвращают одно и то же (одно и то же строковое представление), но это не всегда так. (И да, да, я могу создать переменную foo, где работает eval(), но дело не в этом.)

Дополнительные фактоиды по обеим парам

1. Иногда str() и repr() называются неявно , то есть они вызываются от имени пользователей: когда пользователи выполняют print или Py вызов print() (Py3 +), даже если пользователи не вызывают str() явно, такой вызов выполняется от их имени до отображения объекта.
2. В оболочке Python (интерактивный интерпретатор), если вы вводите переменную в приглашении >>> и нажимаете RETURN, интерпретатор отображает результаты repr(), неявно вызванного для этого объекта.
3. Чтобы соединить str() и repr() с __str__() и __repr__(), осознайте, что вызовы встроенных функций, то есть str(x) или repr(y), приводят к вызову соответствующих специальных методов их объекта: <116134765 > или y.__repr()__
4. Реализуя __str__() и __repr__() для ваших классов Python, вы перегружаете встроенные функции (str() и repr()), позволяя передавать экземпляры ваших классов в str() и repr(). Когда такие вызовы сделаны, они поворачиваются и вызывают классы '__str__() и __repr__() (по # 3).

__str__ может быть вызван для объекта путем вызова str(obj) и должен возвращать удобочитаемую строку.

__repr__ может быть вызван для объекта путем вызова repr(obj) и должен возвращать внутренний объект (поля / атрибуты объекта)

Этот пример может помочь:

class C1:pass

class C2:        
    def __str__(self):
        return str(f"{self.__class__.__name__} class str ")

class C3:        
    def __repr__(self):        
         return str(f"{self.__class__.__name__} class repr")

class C4:        
    def __str__(self):
        return str(f"{self.__class__.__name__} class str ")
    def __repr__(self):        
         return str(f"{self.__class__.__name__} class repr")


ci1 = C1()    
ci2 = C2()  
ci3 = C3()  
ci4 = C4()

print(ci1)       #<__main__.C1 object at 0x0000024C44A80C18>
print(str(ci1))  #<__main__.C1 object at 0x0000024C44A80C18>
print(repr(ci1)) #<__main__.C1 object at 0x0000024C44A80C18>
print(ci2)       #C2 class str
print(str(ci2))  #C2 class str
print(repr(ci2)) #<__main__.C2 object at 0x0000024C44AE12E8>
print(ci3)       #C3 class repr
print(str(ci3))  #C3 class repr
print(repr(ci3)) #C3 class repr
print(ci4)       #C4 class str 
print(str(ci4))  #C4 class str 
print(repr(ci4)) #C4 class repr

1. __str__ должен возвращать строковый объект, тогда как __repr__ может возвращать любое выражение Python.
2. Если реализация __str__ отсутствует, то функция __repr__ используется в качестве резервной. Если реализация функции __repr__ отсутствует, отката нет.
3. Если функция __repr__ возвращает строковое представление объекта, мы можем пропустить реализацию функции __str__.

Источник: ​​https://www.journaldev.com/22460/python-str-repr-functions

__repr__ используется везде, кроме методов print и str (когда определен __str__!)

В двух словах:

class Demo:
  def __repr__(self):
    return 'repr'
  def __str__(self):
    return 'str'

demo = Demo()
print(demo) # use __str__, output 'str' to stdout

s = str(demo) # __str__ is used, return 'str'
r = repr(demo) # __repr__ is used, return 'repr'

import logging
logger = logging.getLogger(logging.INFO)
logger.info(demo) # use __str__, output 'str' to stdout

from pprint import pprint, pformat
pprint(demo) # use __repr__, output 'repr' to stdout
result = pformat(demo) # use __repr__, result is string which value is 'str'

Поймите __str__ и __repr__ интуитивно и навсегда различайте их.

__str__ вернуть строку замаскированного тела данного объекта для чтения глазами
__repr__ вернуть реальное тело данного объекта (вернуть себя) для однозначности для идентификации.

См. Пример

In [30]: str(datetime.datetime.now())
Out[30]: '2017-12-07 15:41:14.002752'
Disguised in string form

Что касается __repr__

In [32]: datetime.datetime.now()
Out[32]: datetime.datetime(2017, 12, 7, 15, 43, 27, 297769)
Presence in real body which allows to be manipulated directly.

Мы можем удобно выполнять арифметические операции с результатами __repr__.

In [33]: datetime.datetime.now()
Out[33]: datetime.datetime(2017, 12, 7, 15, 47, 9, 741521)
In [34]: datetime.datetime(2017, 12, 7, 15, 47, 9, 741521) - datetime.datetime(2
    ...: 017, 12, 7, 15, 43, 27, 297769)
Out[34]: datetime.timedelta(0, 222, 443752)

если применить операцию к __str__

In [35]: '2017-12-07 15:43:14.002752' - '2017-12-07 15:41:14.002752'
TypeError: unsupported operand type(s) for -: 'str' and 'str'

Не возвращает ничего, кроме ошибки.

Другой пример.

In [36]: str('string_body')
Out[36]: 'string_body' # in string form

In [37]: repr('real_body')
Out[37]: "'real_body'" #its real body hide inside

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

Один аспект, которого не хватает в других ответах. Верно, что в целом шаблон таков:

• Цель __str__: удобочитаемый
• Цель __repr__: однозначно, возможно, машиночитаемое через eval

К сожалению, это различие некорректно, поскольку Python REPL и IPython используют __repr__ для печати объектов в консоли REPL (см. Связанные вопросы для Python и IPython). Таким образом, проекты, предназначенные для работы с интерактивной консолью (например, Numpy или Pandas), начали игнорировать вышеуказанные правила и вместо этого предоставлять удобочитаемую реализацию __repr__.

На странице 358 книги Сценарии Python для вычислительной науки Ханса Петтера Лангтангена четко говорится, что

• __repr__ направлен на полное строковое представление объекта;
• __str__ возвращает удобную строку для печати. ​​

Итак, я предпочитаю понимать их как

• repr = воспроизводить
• str = строка (представление)

с точки зрения пользователя хотя это недоразумение я сделал при изучении python.

Небольшой, но хороший пример также приведен на той же странице:

Пример

In [38]: str('s')
Out[38]: 's'

In [39]: repr('s')
Out[39]: "'s'"

In [40]: eval(str('s'))
Traceback (most recent call last):

  File "<ipython-input-40-abd46c0c43e7>", line 1, in <module>
    eval(str('s'))

  File "<string>", line 1, in <module>

NameError: name 's' is not defined


In [41]: eval(repr('s'))
Out[41]: 's'

Из книги Свободный Python :

Основным требованием к объекту Python является предоставление пригодного для использования строковое представление самого себя, которое используется для отладки и ведение журнала, еще один для представления конечным пользователям. Вот почему
в модели данных существуют специальные методы __repr__ и __str__.

str - создает новый строковый объект из данного объекта.

repr - возвращает каноническое строковое представление объекта.

Отличия:

str():

• делает объект доступным для чтения
• генерирует вывод для конечного пользователя

repr():

• требуется код, воспроизводящий объект
• генерирует вывод для разработчика

Помимо всех приведенных ответов, я хотел бы добавить несколько моментов: -

1) __repr__() вызывается, когда вы просто вводите имя объекта в интерактивной консоли Python и нажимаете клавишу ввода.

2) __str__() вызывается, когда вы используете объект с оператором печати. ​​

3) В случае, если __str__ отсутствует, то print и любая функция, использующая str(), вызывает __repr__() объекта.

4) __str__() контейнеров, при вызове будет выполняться метод __repr__() содержащихся в нем элементов.

5) str(), вызванный в пределах __str__(), потенциально может рекурсивно выполняться без базового случая и ошибки максимальной глубины рекурсии.

6) __repr__() может вызывать repr(), который автоматически пытается избежать бесконечной рекурсии, заменяя уже представленный объект на ....

Проще говоря:

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

__repr__ используется для отображения строкового представления объекта .

Допустим, я хочу создать класс Fraction, в котором строковое представление дроби - '(1/2)', а объект (класс Fraction) должен быть представлен как 'Fraction (1,2)'

Итак, мы можем создать простой класс Fraction:

class Fraction:
    def __init__(self, num, den):
        self.__num = num
        self.__den = den

    def __str__(self):
        return '(' + str(self.__num) + '/' + str(self.__den) + ')'

    def __repr__(self):
        return 'Fraction (' + str(self.__num) + ',' + str(self.__den) + ')'



f = Fraction(1,2)
print('I want to represent the Fraction STRING as ' + str(f)) # (1/2)
print('I want to represent the Fraction OBJECT as ', repr(f)) # Fraction (1,2)

Важно помнить, что контейнер __str__ использует содержащиеся объекты __repr__.

>>> from datetime import datetime
>>> from decimal import Decimal
>>> print (Decimal('52'), datetime.now())
(Decimal('52'), datetime.datetime(2015, 11, 16, 10, 51, 26, 185000))
>>> str((Decimal('52'), datetime.now()))
"(Decimal('52'), datetime.datetime(2015, 11, 16, 10, 52, 22, 176000))"

Python отдает предпочтение однозначности перед удобочитаемостью , вызов __str__ из tuple вызывает __repr__ содержащихся объектов, «формальное представление» <958034> . Хотя формальное представление труднее читать, чем неформальное, оно недвусмысленно и более устойчиво к ошибкам.

Отличные ответы уже охватывают разницу между __str__ и __repr__, которая для меня сводится к тому, что первый из них читается даже конечным пользователем, а второй максимально полезен для разработчиков. Учитывая это, я обнаружил, что реализация по умолчанию __repr__ часто не позволяет достичь этой цели, потому что в ней опускается информация, полезная для разработчиков.

По этой причине, если у меня достаточно простой __str__, я обычно просто пытаюсь получить лучшее из обоих миров с помощью чего-то вроде:

def __repr__(self):
    return '{0} ({1})'.format(object.__repr__(self), str(self))

>>> print(decimal.Decimal(23) / decimal.Decimal("1.05"))
21.90476190476190476190476190
>>> decimal.Decimal(23) / decimal.Decimal("1.05")
Decimal('21.90476190476190476190476190')

Когда print() вызывается для результата decimal.Decimal(23) / decimal.Decimal("1.05"), печатается необработанное число; этот вывод находится в строковой форме , которая может быть достигнута с помощью __str__(). Если мы просто введем выражение, мы получим вывод decimal.Decimal - этот вывод находится в репрезентативной форме , что может быть достигнуто с помощью __repr__(). Все объекты Python имеют две формы вывода. Строковая форма предназначена для удобства чтения человеком. Репрезентативная форма предназначена для вывода результатов, которые, если их передать интерпретатору Python, будут (когда это возможно) воспроизвести представленный объект.

В чем разница между __str__ и __repr__ в Python?

__str__ (читается как «строка с двойным подчеркиванием») и __repr__ (читается как «dunder-repper» (для «представления»)) - оба специальных метода, которые возвращают строки в зависимости от состояния предмет.

__repr__ обеспечивает поведение резервного копирования, если __str__ отсутствует.

Итак, сначала следует написать __repr__, который позволит вам восстановить эквивалентный объект из строки, которую он возвращает, например. используя eval или вводя его символ в символ в оболочке Python.

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

__str__

Если вы распечатываете объект или передаете его в format, str.format или str, то, если определен метод __str__, этот метод будет вызван, в противном случае будет использоваться __repr__ .

__repr__

Метод __repr__ вызывается встроенной функцией repr, и это то, что отображается в вашей оболочке python, когда она оценивает выражение, возвращающее объект.

Поскольку он обеспечивает резервную копию для __str__, если вы можете записать только один, начните с __repr__

Вот встроенная справка по repr:

repr(...)
    repr(object) -> string

    Return the canonical string representation of the object.
    For most object types, eval(repr(object)) == object.

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

Реализация по умолчанию __repr__

Объект по умолчанию __repr__ - (исходный код Python на C) примерно так:

def __repr__(self):
    return '<{0}.{1} object at {2}>'.format(
      self.__module__, type(self).__name__, hex(id(self)))

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

<__main__.Foo object at 0x7f80665abdd0>

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

Чем __repr__ может быть полезным?

Давайте посмотрим, насколько это может быть полезно, используя оболочку Python и объекты datetime. Сначала нам нужно импортировать модуль datetime:

import datetime

Если мы вызовем datetime.now в оболочке, мы увидим все, что нам нужно для воссоздания эквивалентного объекта datetime. Это создается datetime __repr__:

>>> datetime.datetime.now()
datetime.datetime(2015, 1, 24, 20, 5, 36, 491180)

Если мы печатаем объект datetime, мы видим удобный для чтения формат (фактически, ISO). Это реализовано с помощью datetime __str__:

>>> print(datetime.datetime.now())
2015-01-24 20:05:44.977951

Легко воссоздать объект, который мы потеряли, потому что мы не присвоили его переменной, скопировав и вставив из вывода __repr__, а затем распечатав его, и мы получили его в том же удобочитаемом для человека выводе. как другой объект:

>>> the_past = datetime.datetime(2015, 1, 24, 20, 5, 36, 491180)
>>> print(the_past)
2015-01-24 20:05:36.491180

Как их реализовать?

В процессе разработки вы захотите иметь возможность воспроизводить объекты в том же состоянии, если это возможно. Так, например, объект datetime определяет __repr__ (исходный код Python). Это довольно сложно из-за всех атрибутов, необходимых для воспроизведения такого объекта:

def __repr__(self):
    """Convert to formal string, for repr()."""
    L = [self._year, self._month, self._day,  # These are never zero
         self._hour, self._minute, self._second, self._microsecond]
    if L[-1] == 0:
        del L[-1]
    if L[-1] == 0:
        del L[-1]
    s = "%s.%s(%s)" % (self.__class__.__module__,
                       self.__class__.__qualname__,
                       ", ".join(map(str, L)))
    if self._tzinfo is not None:
        assert s[-1:] == ")"
        s = s[:-1] + ", tzinfo=%r" % self._tzinfo + ")"
    if self._fold:
        assert s[-1:] == ")"
        s = s[:-1] + ", fold=1)"
    return s

Если вы хотите, чтобы ваш объект имел более удобочитаемое представление, вы можете реализовать __str__ следующим образом. Вот как объект datetime (исходный код Python) реализует __str__, что он легко делает, потому что у него уже есть функция для его отображения в формате ISO:

def __str__(self):
    "Convert to string, for str()."
    return self.isoformat(sep=' ')

Установить __repr__ = __str__?

Это критика другого ответа здесь, предлагающего установить __repr__ = __str__.

Настройка __repr__ = __str__ глупая - __repr__ является запасным вариантом для __str__, и __repr__, написанный для использования разработчиками при отладке, должен быть написан до того, как вы напишете __str__.

Вам нужен __str__ только тогда, когда вам нужно текстовое представление объекта.

Заключение

Определите __repr__ для объектов, которые вы пишете, чтобы у вас и других разработчиков был воспроизводимый пример при его использовании в процессе разработки. Определите __str__, когда вам нужно его строковое представление в удобочитаемой форме.

Короче говоря, цель __repr__ - быть однозначной, а __str__ - быть читаемый.

Вот хороший пример:

>>> import datetime
>>> today = datetime.datetime.now()
>>> str(today)
'2012-03-14 09:21:58.130922'
>>> repr(today)
'datetime.datetime(2012, 3, 14, 9, 21, 58, 130922)'

Прочтите эту документацию для представителя:

repr(object)

Возвращает строку, содержащую печатное представление объекта. Это то же значение, что и при преобразованиях (обратное цитаты). Иногда бывает полезно иметь доступ к этой операции как обычная функция. Для многих типов эта функция пытается чтобы вернуть строку, которая даст объект с тем же значением, когда передается в eval(), в противном случае представление представляет собой строку, заключенную в угловые скобки, содержащие название типа объекта вместе с дополнительной информацией, часто включающей имя и адрес объекта. Класс может контролировать, что возвращает эта функция для его экземпляров, определив метод __repr__().

Вот документация для str:

str(object='')

Вернуть строку, содержащую хорошо печатаемый представление объекта. Для строк это возвращает строку сам. Разница с repr(object) в том, что str(object) не всегда пытайтесь вернуть строку, приемлемую для eval(); это цель - вернуть печатаемую строку. Если аргумент не указан, возвращает пустая строка, ''.

Честно говоря, eval(repr(obj)) никогда не используется. Если вы обнаружите, что используете его, вам следует остановиться, потому что eval опасен, а строки - очень неэффективный способ сериализации ваших объектов (вместо этого используйте pickle).

Поэтому я бы рекомендовал установить __repr__ = __str__. Причина в том, что str(list) вызывает repr для элементов (я считаю, что это один из самых больших недостатков дизайна Python, который не был исправлен Python 3). Фактический repr, вероятно, не будет очень полезным в качестве вывода print [your, objects].

Чтобы уточнить это, по моему опыту, наиболее полезным вариантом использования функции repr является помещение строки внутри другой строки (с использованием форматирования строки). Таким образом, вам не нужно беспокоиться об экранировании кавычек или чего-то еще. Но учтите, что здесь не происходит eval.

Мое практическое правило: __repr__ для разработчиков, __str__ для клиентов.

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

>>> class Sic(object): pass
... 
>>> print str(Sic())
<__main__.Sic object at 0x8b7d0>
>>> print repr(Sic())
<__main__.Sic object at 0x8b7d0>
>>> 

Как видите - никакой разницы и никакой информации, кроме класса и объекта id. Если вы переопределите только один из двух ...:

>>> class Sic(object): 
...   def __repr__(object): return 'foo'
... 
>>> print str(Sic())
foo
>>> print repr(Sic())
foo
>>> class Sic(object):
...   def __str__(object): return 'foo'
... 
>>> print str(Sic())
foo
>>> print repr(Sic())
<__main__.Sic object at 0x2617f0>
>>> 

как видите, если вы переопределите __repr__, это ТАКЖЕ используется для __str__, но не наоборот.

Другие важные моменты, которые необходимо знать: __str__ во встроенном контейнере использует __repr__, а НЕ __str__ для элементов, которые он содержит. И, несмотря на слова на эту тему, встречающиеся в типичных документах, вряд ли кто-то позаботится о том, чтобы __repr__ объектов представлял собой строку, которую eval может использовать для создания равного объекта (это слишком сложно, И не зная, как соответствующий модуль был фактически импортирован, что делает это фактически невозможным).

Итак, мой совет: сосредоточьтесь на том, чтобы сделать __str__ разумно удобочитаемым, а __repr__ настолько однозначным, насколько это возможно, даже если это мешает нечеткой недостижимой цели сделать возвращаемое значение __repr__ приемлемым как введите в __eval__!

__repr__ : представление объекта python обычно eval преобразует его обратно в этот объект

__str__ : это то, что вы думаете, это объект в текстовой форме

например,

>>> s="""w'o"w"""
>>> repr(s)
'\'w\\\'o"w\''
>>> str(s)
'w\'o"w'
>>> eval(str(s))==s
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1
    w'o"w
       ^
SyntaxError: EOL while scanning single-quoted string
>>> eval(repr(s))==s
True

Из (неофициальной) справочной вики по Python (архивная копия) от effbot:

__str__ « вычисляет« неформальное »строковое представление объекта. Оно отличается от __repr__ тем, что оно не обязательно должно быть действительным выражением Python: вместо него можно использовать более удобное или краткое представление . "