[prev in list] [next in list] [prev in thread] [next in thread]
List: zope3-checkins
Subject: [Zope3-checkins] SVN: Zope3/trunk/src/zope/interface/README.ru.txt
From: Dmitry Vasiliev <dima () hlabs ! spb ! ru>
Date: 2005-04-28 11:56:23
Message-ID: 20050428120011.B06602032C4 () mail ! zope ! org
[Download RAW message or body]
Log message for revision 30207:
Fixed some typos
Changed:
U Zope3/trunk/src/zope/interface/README.ru.txt
-=-
Modified: Zope3/trunk/src/zope/interface/README.ru.txt
===================================================================
--- Zope3/trunk/src/zope/interface/README.ru.txt 2005-04-28 10:35:17 UTC (rev 30206)
+++ Zope3/trunk/src/zope/interface/README.ru.txt 2005-04-28 12:00:11 UTC (rev 30207)
@@ -15,7 +15,7 @@
- Инварианты, представленные условиями \
которые должны быть соблюдены для объектов \
предоставляющих интерфейс
-Определения атрибутов определяют конкретные \
атрибуты. Они определяют +Определения \
атрибутов описывают конкретные атрибуты. Они \
определяют имя атрибута и предоставляют \
документацию и ограничения для значений \
атрибута. Определения атрибутов могут быть \
заданы несколькими путями как мы увидим ниже.
@@ -61,12 +61,12 @@
Наш интерфейс определяет два атрибута:
`x`
- Это простейшая форма определения атрибутов. \
Здесь определяются имя
- и строка документации. Здесь формально не \
определяется ничего более. + Это простейшая \
форма определения атрибутов. Определяются имя \
+ и строка документации. Формально здесь не \
определяется ничего более.
`bar`
Это метод. Методы определяются как обычные \
функции. Метод - это просто
- атрибут который должен быть вызываемым с \
подробной сигнатурой, + атрибут который \
должен быть вызываемым с указанием сигнатуры, \
предоставляемой определением функции.
Надо отметить, что аргумент `self` не \
указывается для `bar`. Интерфейс @@ -96,7 +96,7 @@
>>> IFoo.get('y')
-Мы можем использовать `in` для определения \
содержит ли интерфейс +Можно использовать `in` \
для определения содержит ли интерфейс \
определенное имя::
>>> 'x' in IFoo
@@ -142,7 +142,7 @@
Мы обычно говорим что классы *реализуют* \
интерфейсы. Если класс реализует интерфейс, \
тогда экземпляры этого класса предоставляют \
данный интерфейс. Объекты предоставляют \
интерфейсы которые их классы
- реализуют [#factory]_. (Объекты могут \
предоставлять интерфейсы напрямую + \
реализуют [#factory]_. (Объекты также могут \
предоставлять интерфейсы напрямую плюс к тем \
которые реализуют их классы.)
Важно помнить, что классы обычно не \
предоставляют интерфейсы которые @@ -158,7 +158,7 @@
Обявление реализуемых интерфесов
--------------------------------
-Наиболее общий путь для объявления \
интерфейсов - это использование +Наиболее \
часто используемый путь для объявления \
интерфейсов - это использование функции implements \
в определении класса::
>>> class Foo:
@@ -174,14 +174,14 @@
... return "Foo(%s)" % self.x
В этом примере мы объявили, что `Foo` реализует \
`IFoo`. Это значит, что
-экземпляры `Foo` предоставляют `IFoo`. После \
данного объявления здесь
-несколько путей для анализа объявления. \
Во-первых мы можем спросить +экземпляры `Foo` \
предоставляют `IFoo`. После данного объявления \
есть +несколько путей для анализа объявлений. \
Во-первых мы можем спросить что интерфейс \
реализован классом::
>>> IFoo.implementedBy(Foo)
True
-Также мы можем спросить если интерфейс \
предоставляется объектами:: +Также мы можем \
спросить если интерфейс предоставляется \
объектами класса::
>>> foo = Foo()
>>> IFoo.providedBy(foo)
@@ -197,7 +197,7 @@
>>> list(zope.interface.implementedBy(Foo))
[<InterfaceClass __main__.IFoo>]
-Ошибочно спрашивать про интерфейсы \
реализуемые невызываемым объектом:: +Это \
ошибка спрашивать про интерфейсы реализуемые \
невызываемым объектом::
>>> IFoo.implementedBy(foo)
Traceback (most recent call last):
@@ -209,7 +209,7 @@
...
TypeError: ('ImplementedBy called for non-factory', Foo(None))
-Также мы можем узнать какие интерфейсы \
предоставляются объектами:: +Также можно \
узнать какие интерфейсы предоставляются \
объектами::
>>> list(zope.interface.providedBy(foo))
[<InterfaceClass __main__.IFoo>]
@@ -217,8 +217,8 @@
[]
Мы можем объявить интерфейсы реализуемые \
другими фабриками (кроме классов).
-Это можно сделать используя в стиле Python 2.4 \
декоратор `implementer`.
-Для версий Python до 2.4 это будет выглядеть \
следующим образом: +Это можно сделать \
используя декоратор `implementer` (в стиле Python 2.4). \
+Для версий Python ниже 2.4 это будет выглядеть \
следующим образом:
>>> def yfoo(y):
... foo = Foo()
@@ -249,7 +249,7 @@
Мы можем объявлять интерфейсы напрямую \
предоставляемые объектами. Предположим что \
мы хотим документировать что делает метод \
`__init__` класса `Foo`. Это
*точно* не часть `IFoo`. Обычно мы не должны \
напрямую вызывать метод `__init__`
-для экземпляров Foo. Скорее `__init__` метод - это \
часть метода `__call__` +для экземпляров Foo. Скорее \
метод `__init__` является частью метода `__call__` \
класса `Foo`::
>>> class IFooFactory(zope.interface.Interface):
@@ -261,12 +261,12 @@
... The argument provides the initial value for x ...
... """
-Это класс предоставляющий данный интерфейс, \
таким образом мы объявляем
-интерфейс класса::
+У нас есть класс предоставляющий данный \
интерфейс, таким образом мы можем +объявить \
интерфейс класса::
>>> zope.interface.directlyProvides(Foo, IFooFactory)
-Теперь мы видим, что Foo предоставляет \
интерфейсы:: +Теперь мы видим, что Foo уже \
предоставляет интерфейсы::
>>> list(zope.interface.providedBy(Foo))
[<InterfaceClass __main__.IFooFactory>]
@@ -275,7 +275,7 @@
Объявление интерфейсов класса достаточно \
частая операция и для нее есть специальная \
функция объявления `classProvides`, которая \
позволяет объявлять
-интерфейсы из определения класса::
+интерфейсы при определении класса::
>>> class Foo2:
... zope.interface.implements(IFoo)
@@ -295,13 +295,13 @@
>>> IFooFactory.providedBy(Foo2)
True
-Похожая функция `moduleProvides` поддерживает \
объявление интерфейсов из
-определения модуля. Для примера смотрите \
использование вызова +Похожая функция \
`moduleProvides` поддерживает объявление интерфейсов \
при +определении модуля. Для примера смотрите \
использование вызова `moduleProvides` в \
`zope.interface.__init__`, который объявляет, что пакет \
`zope.interface` предоставляет `IInterfaceDeclaration`.
Иногда мы хотим объявить интерфейсы \
экземпляров, даже если эти экземпляры
-берут интерфейсы от своих классов. \
Предположим, что мы создаем новый +уже берут \
интерфейсы от своих классов. Предположим, что \
мы создаем новый интерфейс `ISpecial`::
>>> class ISpecial(zope.interface.Interface):
@@ -325,14 +325,14 @@
>>> zope.interface.directlyProvides(foo, ISpecial)
-затем новый интерфейс включается в список \
предоставляемых интерфейсов:: +таким образом \
новый интерфейс включается в список \
предоставляемых интерфейсов::
>>> ISpecial.providedBy(foo)
True
>>> list(zope.interface.providedBy(foo))
[<InterfaceClass __main__.ISpecial>, <InterfaceClass __main__.IFoo>]
-Теперь мы можем определить, что интерфейсы \
напрямую предоставляются +Мы также можем \
определить, что интерфейсы напрямую \
предоставляются объектами::
>>> list(zope.interface.directlyProvidedBy(foo))
@@ -409,7 +409,7 @@
<class 'zope.interface.declarations.Implements'>
Объекты объявления и объекты интерфейсов во \
многом похожи друг на друга.
-По факту они разделяют общий базовый класс. \
Важно понять, что они могут +На самом деле они \
даже имеют общий базовый класс. Важно понять, \
что они могут использоваться там где в \
объявлениях ожидаются интерфейсы. Вот простой \
пример::
@@ -423,7 +423,7 @@
... return "I'm special because %s" % self.reason
Объявление здесь практически такое же как
-``zope.interface.implements(ISpecial)``, различаются только \
порядком +``zope.interface.implements(ISpecial)``, отличие \
только в порядке интерфейсов в итоговом \
объявления::
>>> list(zope.interface.implementedBy(Special2))
@@ -467,10 +467,10 @@
'eek in baz blah'
Мы были осторожны переопределяя eek \
совместимым путем. Когда интерфейс
-расширяется, расширяемый интерфейс должен \
быть совместимым [#compat]_ с +расширяется, \
расширенный интерфейс должен быть \
совместимым [#compat]_ с расширяемыми \
интерфейсами.
-Мы можем запросить расширяет ли один \
интерфейс другой:: +Мы можем запросить \
расширяет ли один из интерфейсов другой::
>>> IBaz.extends(IFoo)
True
@@ -483,7 +483,7 @@
False
Иногда мы можем хотеть что бы они расширяли \
сами себя, но вместо этого
-мы использовать `isOrExtends`::
+мы можем использовать `isOrExtends`::
>>> IBaz.isOrExtends(IBaz)
True
@@ -494,13 +494,13 @@
Когда мы применяем итерацию к интерфесу мы \
получаем все имена которые он определяет \
включая имена определенные для базовых \
интерфесов. Иногда
-мы хотим получить *только* имена определенные \
напрямую интерфейсом. +мы хотим получить \
*только* имена определенные интерфейсом \
напрямую. Для этого мы используем метод `names`::
>>> list(IBaz.names())
['eek']
-Наследование в случае спецификаций атрибутов
+Наследование в случае определения атрибутов
--------------------------------------------
Интерфейс может переопределять определения \
атрибутов из базовых интерфейсов. @@ -523,7 +523,7 @@
>>> class ISub(IBase1, IBase2):
... pass
-Определение ISub для foo будет из IBase2 т.к. IBase2 \
более специфичный для +Определение ISub для foo \
будет из IBase2 т.к. IBase2 более специфичен для IBase:
>>> ISub['foo'].__doc__
@@ -532,7 +532,7 @@
Заметим, что это отличается от поиска в \
глубину.
Иногда полезно узнать, что интерфейс \
определяет атрибут напрямую. Мы можем
-использовать метод direct для получения \
напрямую определенных интерфейсов: \
+использовать метод direct для получения \
напрямую определенных атрибутов:
>>> IBase.direct('foo').__doc__
'base foo doc'
@@ -542,8 +542,8 @@
Спецификации
------------
-Интерфейсы и объявления - это специальные \
случаии спецификаций. То что было
-описано выше для наследования интерфейсов \
можно применить и к объявлениям и +Интерфейсы \
и объявления - это специальные случаи \
спецификаций. Описание +выше для наследования \
интерфейсов можно применить и к объявлениям и \
к спецификациям. Объявления фактически \
расширяют интерфейсы которые они объявляют:
@@ -562,7 +562,7 @@
>>> baz_implements.isOrExtends(baz_implements)
True
-Спецификации (интерфейсы и объявления) \
предоставляют `__sro__` атрибут +Спецификации \
(интерфейсы и объявления) предоставляют \
атрибут `__sro__` который описывает спецификацию \
и всех ее предков:
>>> baz_implements.__sro__
@@ -572,11 +572,11 @@
<InterfaceClass __main__.IBlat>,
<InterfaceClass zope.interface.Interface>)
-Отмеченные значения
+Помеченные значения
===================
Интерфейсы и описания атрибутов поддерживают \
механизм расширения
-позоимствованный от UML, называемый \
"отмеченные значения" который позволяет \
+заимствованный из UML и называемый "помеченные \
значения" который позволяет сохранять \
дополнительные данные::
>>> IFoo.setTaggedValue('date-modified', '2004-04-01')
@@ -591,7 +591,7 @@
>>> tags
['author', 'date-modified']
-Атрибуты функций конвертируются в отмеченные \
значения когда создаются +Атрибуты функций \
конвертируются в помеченные значения когда \
создаются определения атрибутов метода::
>>> class IBazFactory(zope.interface.Interface):
@@ -606,10 +606,10 @@
==========
Интерфейсы могут описывать условия которые \
должны быть соблюдены для объектов
-которые предоставляют их. Эти условия \
описываются используя один или \
больше
-инфвариантов. Инварианты - это вызываемые \
объекты которые будут вызваны
-с объектом предоставляющим интерфейс. \
Инвариант должен выкинуть исключение
-`Invalid` если условие не соблюдено. Пример::
+которые их предоставляют. Эти условия \
описываются используя один или более \
+инвариантов. Инварианты - это вызываемые \
объекты которые будут вызваны +с объектом \
предоставляющим интерфейс в качестве \
параметра. Инвариант +должен выкинуть \
исключение `Invalid` если условие не соблюдено. \
Например::
>>> class RangeError(zope.interface.Invalid):
... """A range has invalid limits"""
@@ -620,7 +620,7 @@
... if ob.max < ob.min:
... raise RangeError(ob)
-Определив эти инварианты мы можем \
использовать их в определении интерфейсов:: \
+Определив этот инвариант мы можем \
использовать его в определении интерфейсов::
>>> class IRange(zope.interface.Interface):
... min = zope.interface.Attribute("Lower bound")
@@ -646,9 +646,9 @@
...
RangeError: Range(2, 1)
-В случае нескольких инвариантов мы можем \
хотеть остановить проверку после
-первой ошибки. Если мы передадим список для \
`validateInvariants` тогда
-единственное исключение `Invalid` будет выкинуто \
со списком исключений +В случае нескольких \
инвариантов мы можем захотеть остановить \
проверку после +первой ошибки. Если мы \
передадим в `validateInvariants` пустой список тогда \
+будет выкинуто единственное исключение `Invalid` \
со списком исключений как аргументом::
>>> errors = []
@@ -665,25 +665,25 @@
.. [#create] Основная причина по которой мы \
наследуемся от `Interface` - это
что бы быть уверенными в том, что \
ключевое слово class будет
- создавать интерфейс а не класс.
+ создавать интерфейс, а не класс.
Есть возможность создать интерфейсы \
вызвав специальный
- класс интерфейса напрямую. Делая это \
возможно (и в редких + класс интерфейса \
напрямую. Делая это, возможно (и в \
редких
случаях полезно) создать интерфейсы \
которые не наследуются
- от `Interface`. Использование этой техники \
выходит за рамки
- данного документа.
+ от `Interface`. Однако использование этой \
техники выходит + за рамки данного \
документа.
.. [#factory] Классы - это фабрики. Они могут быть \
вызваны для создания
своих экземпляров. Мы ожидаем что в \
итоге мы расширим
концепцию реализации на другие типы \
фабрик, таким образом
мы сможем объявлять интерфейсы \
предоставляемые созданными
- объектами.
+ фабриками объектами.
-.. [#compat] Цель - заменяемость. Объект который \
предоставляет расширенные
- интерфейсы должен быть заменяем для \
объектов которые
- предоставляют расширенный интерфейс. \
В нашем примере объект
- который предоставляет IBaz должен быть \
используемым в
- не зависимости если ожидается объект \
который предоставляет IBlat. +.. [#compat] Цель - \
заменяемость. Объект который предоставляет \
расширенный + интерфейс должен быть \
заменяем в качестве объектов которые + \
предоставляют расширяемый интерфейс. В нашем \
примере объект + который предоставляет \
IBaz должен быть используемым и + в случае \
если ожидается объект который предоставляет \
IBlat.
еализация интерфейса не требует \
этого. Но возможно в дальнейшем
она должна будет делать какие-либо \
проверки.
_______________________________________________
Zope3-Checkins mailing list
Zope3-Checkins@zope.org
http://mail.zope.org/mailman/listinfo/zope3-checkins
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic