[Zope3-checkins] SVN: Zope3/trunk/src/zope/interface/README.ru.txt Fixed some typos

[Dmitry Vasiliev]

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.
 
              Реализация интерфейса не требует этого. Но возможно в дальнейшем
              она должна будет делать какие-либо проверки.