Merge pull request #3856 from sshine/make-python3-default

[Python] Make Python 3 default

2 files changed, 225 insertions, 225 deletions

diff --git a/ru-ru/python-ru.html.markdown b/ru-ru/python-ru.html.markdown
index 6087a686..b2c00baf 100644
--- a/ru-ru/python-ru.html.markdown
+++ b/ru-ru/python-ru.html.markdown
@@ -1,23 +1,23 @@
 ---
-language: python
+language: Python
 lang: ru-ru
 contributors:
     - ["Louie Dinh", "http://ldinh.ca"]
+    - ["Steven Basart", "http://github.com/xksteven"]
 translators:
-    - ["Yury Timofeev", "http://twitter.com/gagar1n"]
     - ["Andre Polykanine", "https://github.com/Oire"]
 filename: learnpython-ru.py
 ---
 
 Язык Python был создан Гвидо ван Россумом в начале 90-х. Сейчас это один из
 самых популярных языков. Я влюбился в Python за понятный и доходчивый синтаксис  — это
-почти исполняемый псевдокод.
+почти что исполняемый псевдокод.
 
 С благодарностью жду ваших отзывов: [@louiedinh](http://twitter.com/louiedinh)
 или louiedinh [at] [почтовый сервис Google]
 
-Замечание: Эта статья относится к Python 2.7, но должно работать и в других версиях Python 2.x.
-Чтобы изучить Python 3.x, обратитесь к статье по Python 3.
+Замечание: Эта статья относится только к Python 3.
+Если вы хотите изучить Python 2.7, обратитесь к другой статье.
 
 ```python
 # Однострочные комментарии начинаются с символа решётки.
@@ -37,16 +37,9 @@ filename: learnpython-ru.py
 1 + 1 #=> 2
 8 - 1 #=> 7
 10 * 2 #=> 20
-35 / 5 #=> 7
 
-# А вот деление немного сложнее. В этом случае происходит деление 
-# целых чисел, и результат автоматически округляется в меньшую сторону.
-5 / 2 #=> 2
-
-# Чтобы делить правильно, сначала нужно немного узнать о числах
-# с плавающей запятой.
-2.0     # Это число с плавающей запятой
-11.0 / 4.0 #=> 2.75 Вооот... Так гораздо лучше
+# Кроме деления, которое по умолчанию возвращает число с плавающей запятой
+35 / 5  # => 7.0
 
 # Результат целочисленного деления округляется в меньшую сторону
 # как для положительных, так и для отрицательных чисел.
@@ -55,6 +48,10 @@ filename: learnpython-ru.py
 -5 // 3  # => -2
 -5.0 // 3.0 # => -2.0
 
+# Когда вы используете числа с плавающей запятой, 
+# результатом будет также число с плавающей запятой
+3 * 2.0 # => 6.0
+
 # Остаток от деления
 7 % 3 # => 1
 
@@ -64,6 +61,14 @@ filename: learnpython-ru.py
 # Приоритет операций указывается скобками
 (1 + 3) * 2 #=> 8
 
+# Для логических (булевых) значений существует отдельный примитивный тип
+True
+False
+
+# Для отрицания используется ключевое слово not
+not True #=> False
+not False #=> True
+
 # Логические операторы
 # Обратите внимание: ключевые слова «and» и «or» чувствительны к регистру букв
 True and False #=> False
@@ -76,10 +81,6 @@ False or True #=> True
 2 == True #=> False
 1 == True #=> True
 
-# Для отрицания используется ключевое слово not
-not True #=> False
-not False #=> True
-
 # Равенство — это ==
 1 == 1 #=> True
 2 == 1 #=> False
@@ -94,7 +95,7 @@ not False #=> True
 2 <= 2 #=> True
 2 >= 2 #=> True
 
-# Сравнения могут быть записаны цепочкой!
+# Сравнения могут быть записаны цепочкой:
 1 < 2 < 3 #=> True
 2 < 3 < 2 #=> False
 
@@ -102,75 +103,70 @@ not False #=> True
 "Это строка."
 'Это тоже строка.'
 
-# И строки тоже можно складывать!
+# И строки тоже могут складываться! Хотя лучше не злоупотребляйте этим.
 "Привет " + "мир!" #=> "Привет мир!"
 
-# ... или умножать
-"Привет" * 3  # => "ПриветПриветПривет"
+# Строки можно умножать.
+"aa" * 4 #=> "aaaaaaaa"
 
 # Со строкой можно работать, как со списком символов
 "Это строка"[0] #=> 'Э'
 
-# Символ % используется для форматирования строк, например:
-"%s могут быть %s" % ("строки", "интерполированы")
-
-# Новый способ форматирования строк — использование метода format.
-# Это предпочитаемый способ.
+# Метод format используется для форматирования строк:
 "{0} могут быть {1}".format("строки", "форматированы")
 
+# Вы можете повторять аргументы форматирования, чтобы меньше печатать.
+"Ехал {0} через реку, видит {0} - в реке {1}! Сунул {0} руку в реку, {1} за руку греку цап!".format("грека", "рак")
+#=> "Ехал грека через реку, видит грека - в реке рак! Сунул грека руку в реку, рак за руку греку цап!"
 # Если вы не хотите считать, можете использовать ключевые слова.
 "{name} хочет есть {food}".format(name="Боб", food="лазанью")
 
+# Если ваш код на Python 3 нужно запускать также и под Python 2.5 и ниже,
+# вы также можете использовать старый способ форматирования:
+"%s можно %s %s способом" % ("строки", "интерполировать", "старым")
+
 # None является объектом
 None #=> None
 
-# Не используйте оператор равенства '=='' для сравнения 
-# объектов с None. Используйте для этого «is»
+# Не используйте оператор равенства '==' для сравнения 
+# объектов с None. Используйте для этого 'is'
 "etc" is None #=> False
 None is None  #=> True
 
-# Оператор 'is' проверяет идентичность объектов. Он не 
+# Оператор «is» проверяет идентичность объектов. Он не 
 # очень полезен при работе с примитивными типами, но 
 # зато просто незаменим при работе с объектами.
 
-# None, 0 и пустые строки/списки равны False.
+# None, 0 и пустые строки/списки/словари приводятся к False.
 # Все остальные значения равны True
-0 == False  #=> True
-"" == False #=> True
+bool(0)  # => False
+bool("")  # => False
+bool([]) #=> False
+bool({}) #=> False
 
 
 ####################################################
 ## 2. Переменные и коллекции
 ####################################################
 
-# В Python есть оператор print, доступный в версиях 2.x, но удалённый в версии 3
-print "Я Python. Приятно познакомиться!"
-# В Python также есть функция print(), доступная в версиях 2.7 и 3,
-# Но для версии 2.7 нужно добавить следующий импорт модуля (раскомментируйте)):
-# from __future__ import print_function
-print("Я тоже Python! ")
+# В Python есть функция Print
+print("Я Python. Приятно познакомиться!")
 
 # Объявлять переменные перед инициализацией не нужно.
-some_var = 5    # По соглашению используется нижний_регистр_с_подчёркиваниями
+# По соглашению используется нижний_регистр_с_подчёркиваниями
+some_var = 5
 some_var #=> 5
 
 # При попытке доступа к неинициализированной переменной
 # выбрасывается исключение.
-# См. раздел «Поток управления» для информации об исключениях.
-some_other_var  # Выбрасывает ошибку именования
-
-# if может быть использован как выражение
-"yahoo!" if 3 > 2 else 2 #=> "yahoo!"
+# Об исключениях см. раздел «Поток управления и итерируемые объекты».
+some_unknown_var  # Выбрасывает ошибку именования
 
 # Списки хранят последовательности
 li = []
 # Можно сразу начать с заполненного списка
 other_li = [4, 5, 6]
 
-# строка разделена в список
-a="adambard"
-list(a) #=> ['a','d','a','m','b','a','r','d']
-
 # Объекты добавляются в конец списка методом append
 li.append(1)    # [1]
 li.append(2)    # [1, 2]
@@ -183,10 +179,6 @@ li.append(3)    # [1, 2, 4, 3].
 
 # Обращайтесь со списком, как с обычным массивом
 li[0] #=> 1
-# Присваивайте новые значения уже инициализированным индексам с помощью =
-li[0] = 42
-li[0]  # => 42
-li[0] = 1  # Обратите внимание: возвращаемся на исходное значение
 # Обратимся к последнему элементу
 li[-1] #=> 3
 
@@ -208,11 +200,11 @@ li[::-1]   # => [3, 4, 2, 1]
 # li[начало:конец:шаг]
 
 # Удаляем произвольные элементы из списка оператором del
-del li[2] # li теперь [1, 2, 3]
+del li[2] # [1, 2, 3]
 
 # Вы можете складывать, или, как ещё говорят, конкатенировать списки
-li + other_li #=> [1, 2, 3, 4, 5, 6]  — Замечание: li и other_li не изменяются
 # Обратите внимание: значения li и other_li при этом не изменились.
+li + other_li #=> [1, 2, 3, 4, 5, 6]  — Замечание: li и other_li не изменяются
 
 # Объединять списки можно методом extend
 li.extend(other_li) # Теперь li содержит [1, 2, 3, 4, 5, 6]
@@ -242,6 +234,7 @@ d, e, f = 4, 5, 6
 # Обратите внимание, как легко поменять местами значения двух переменных
 e, d = d, e     # теперь d == 5, а e == 4
 
+
 #  Словари содержат ассоциативные массивы
 empty_dict = {}
 # Вот так описывается предзаполненный словарь
@@ -251,13 +244,17 @@ filled_dict = {"one": 1, "two": 2, "three": 3}
 # что индекс — у словарей он называется ключом — не обязан быть числом
 filled_dict["one"] #=> 1
 
-# Можно получить все ключи в виде списка с помощью метода keys
-filled_dict.keys() #=> ["three", "two", "one"]
+# Все ключи в виде списка получаются с помощью метода keys(). 
+# Его вызов нужно обернуть в list(), так как обратно мы получаем
+# итерируемый объект, о которых поговорим позднее.
+list(filled_dict.keys())   # => ["three", "two", "one"]
 # Замечание: сохранение порядка ключей в словаре не гарантируется
 # Ваши результаты могут не совпадать с этими.
 
-# Можно получить и все значения в виде списка, используйте метод values
-filled_dict.values() #=> [3, 2, 1]
+# Все значения в виде списка можно получить с помощью values().
+# И снова нам нужно обернуть вызов в list(), чтобы превратить
+# итерируемый объект в список.
+list(filled_dict.values())   # => [3, 2, 1]
 # То же самое замечание насчёт порядка ключей справедливо и здесь
 
 # При помощи оператора in можно проверять ключи на вхождение в словарь
@@ -274,29 +271,28 @@ filled_dict.get("four") #=> None
 # возвращено при отсутствии указанного ключа
 filled_dict.get("one", 4) #=> 1
 filled_dict.get("four", 4) #=> 4
-# Обратите внимание, что filled_dict.get("four") всё ещё => None
-# (get не устанавливает значение элемента словаря)
-
-# Присваивайте значение ключам так же, как и в списках
-filled_dict["four"] = 4  # теперь filled_dict["four"] => 4
 
-# Метод setdefault() вставляет пару ключ-значение, только если такого ключа нет
+# Метод setdefault вставляет пару ключ-значение, только если такого ключа нет
 filled_dict.setdefault("five", 5) #filled_dict["five"] возвращает 5
 filled_dict.setdefault("five", 6) #filled_dict["five"] по-прежнему возвращает 5
 
+# Добавление элементов в словарь
+filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4}
+#filled_dict["four"] = 4  # Другой способ добавления элементов
 
-# Множества содержат... ну, в общем, множества
-# (которые похожи на списки, только в них не может быть дублирующихся элементов)
-empty_set = set()
-# Инициализация множества набором значений
-some_set = set([1,2,2,3,4]) # some_set теперь равно set([1, 2, 3, 4])
+# Удаляйте ключи из словаря с помощью оператора del
+del filled_dict["one"]  # Удаляет ключ «one» из словаря
 
-# Порядок сортировки не гарантируется, хотя иногда они выглядят отсортированными
-another_set = set([4, 3, 2, 2, 1])  # another_set теперь set([1, 2, 3, 4])
 
-# Начиная с Python 2.7, вы можете использовать {}, чтобы объявить множество
+# Множества содержат... ну, в общем, множества
+empty_set = set()
+# Инициализация множества набором значений.
+# Да, оно выглядит примерно как словарь… ну извините, так уж вышло.
 filled_set = {1, 2, 2, 3, 4} # => {1, 2, 3, 4}
 
+# Множеству можно назначать новую переменную
+filled_set = some_set
+
 # Добавление новых элементов в множество
 filled_set.add(5) # filled_set равно {1, 2, 3, 4, 5}
 
@@ -316,7 +312,7 @@ filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
 
 
 ####################################################
-## 3. Поток управления
+## 3. Поток управления и итерируемые объекты
 ####################################################
 
 # Для начала заведём переменную
@@ -332,17 +328,13 @@ else:           # Это тоже необязательно.
     print("some_var равно 10.")
 
 
-"""
-Циклы For проходят по спискам
-
-Результат:
-    собака — это млекопитающее
-    кошка — это млекопитающее
-    мышь — это млекопитающее
-"""
+# Циклы For проходят по спискам. Результат:
+    # собака — это млекопитающее
+    # кошка — это млекопитающее
+    # мышь — это млекопитающее
 for animal in ["собака", "кошка", "мышь"]:
-    # Можете использовать оператор % для интерполяции форматированных строк
-    print("%s — это млекопитающее" % animal)
+    # Можете использовать format() для интерполяции форматированных строк
+    print("{} — это млекопитающее".format(animal))
     
 """
 «range(число)» возвращает список чисел
@@ -370,8 +362,6 @@ while x < 4:
     x += 1  # Краткая запись для x = x + 1
 
 # Обрабатывайте исключения блоками try/except
-
-# Работает в Python 2.6 и выше:
 try:
     # Чтобы выбросить ошибку, используется raise
     raise IndexError("Это ошибка индекса")
@@ -384,6 +374,37 @@ except (TypeError, NameError):
 else:   # Необязательное выражение. Должно следовать за последним блоком except
     print("Всё хорошо!")   # Выполнится, только если не было никаких исключений
 
+# Python предоставляет фундаментальную абстракцию,
+# которая называется итерируемым объектом (an iterable).
+# Итерируемый объект — это объект, который воспринимается как последовательность.
+# Объект, который возвратила функция range(), итерируемый.
+filled_dict = {"one": 1, "two": 2, "three": 3}
+our_iterable = filled_dict.keys()
+print(our_iterable) #=> range(1,10). Это объект, реализующий интерфейс iterable
+
+# Мы можем проходить по нему циклом.
+for i in our_iterable:
+    print(i)    # Выводит one, two, three
+
+# Но мы не можем обращаться к элементу по индексу.
+our_iterable[1]  # Выбрасывает ошибку типа
+
+# Итерируемый объект знает, как создавать итератор.
+our_iterator = iter(our_iterable)
+
+# Итератор может запоминать состояние при проходе по объекту.
+# Мы получаем следующий объект, вызывая функцию __next__.
+our_iterator.__next__()  #=> "one"
+
+# Он сохраняет состояние при вызове __next__.
+our_iterator.__next__()  #=> "two"
+our_iterator.__next__()  #=> "three"
+
+# Возвратив все данные, итератор выбрасывает исключение StopIterator
+our_iterator.__next__() # Выбрасывает исключение остановки итератора
+
+# Вы можете получить сразу все элементы итератора, вызвав на нём функцию list().
+list(filled_dict.keys())  #=> Возвращает ["one", "two", "three"]
 
 
 ####################################################
@@ -401,8 +422,7 @@ add(5, 6) #=> выводит «x равен 5, а y равен 6» и возвр
 # Другой способ вызова функции — вызов с именованными аргументами
 add(y=6, x=5)   # Именованные аргументы можно указывать в любом порядке.
 
-# Вы можете определить функцию, принимающую переменное число аргументов,
-# которые будут интерпретированы как кортеж, если вы не используете *
+# Вы можете определить функцию, принимающую переменное число аргументов
 def varargs(*args):
     return args
 
@@ -410,8 +430,7 @@ varargs(1, 2, 3) #=> (1,2,3)
 
 
 # А также можете определить функцию, принимающую переменное число
-# именованных аргументов, которые будут интерпретированы как словарь,
-# если вы не используете **
+# именованных аргументов
 def keyword_args(**kwargs):
     return kwargs
 
@@ -436,14 +455,6 @@ all_the_args(*args) # эквивалентно foo(1, 2, 3, 4)
 all_the_args(**kwargs) # эквивалентно foo(a=3, b=4)
 all_the_args(*args, **kwargs) # эквивалентно foo(1, 2, 3, 4, a=3, b=4)
 
-# вы можете передавать переменное число позиционных или именованных аргументов
-# другим функциям, которые их принимают, распаковывая их с помощью
-# * или ** соответственно
-def pass_all_the_args(*args, **kwargs):
-    all_the_args(*args, **kwargs)
-    print varargs(*args)
-    print keyword_args(**kwargs)
-
 # Область определения функций
 x = 5
 
@@ -502,7 +513,7 @@ class Human(object):
 
     # Метод экземпляра. Все методы принимают self в качестве первого аргумента
     def say(self, msg):
-       return "%s: %s" % (self.name, msg)
+        return "{name}: {message}".format(name=self.name, message=msg)
 
     # Метод класса разделяется между всеми экземплярами
     # Они вызываются с указыванием вызывающего класса в качестве первого аргумента
@@ -555,9 +566,6 @@ from math import *
 # Можете сокращать имена модулей
 import math as m
 math.sqrt(16) == m.sqrt(16) #=> True
-# Вы также можете убедиться, что функции эквивалентны
-from math import sqrt
-math.sqrt == m.sqrt == sqrt  # => True
 
 # Модули в Python — это обычные Python-файлы. Вы
 # можете писать свои модули и импортировать их. Название
@@ -581,15 +589,14 @@ def double_numbers(iterable):
 # Он не возвращает все значения разом, а создаёт каждое из них при каждой
 # итерации.  Это значит, что значения больше 15 в double_numbers
 # обработаны не будут.
-# Обратите внимание: xrange — это генератор, который делает то же, что и range.
+# Обратите внимание: range — это тоже генератор.
 # Создание списка чисел от 1 до 900000000 требует много места и времени.
-# xrange создаёт объект генератора, а не список сразу, как это делает range.
 # Если нам нужно имя переменной, совпадающее с ключевым словом Python,
 # мы используем подчёркивание в конце
-xrange_ = xrange(1, 900000000)
+range_ = range(1, 900000000)
 
 # Будет удваивать все числа, пока результат не превысит 30
-for i in double_numbers(xrange_):
+for i in double_numbers(range_):
     print(i)
     if i >= 30:
         break
@@ -630,9 +637,10 @@ print(say(say_please=True)) # Вы не купите мне пива? Пожал
 
 * [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
 * [Dive Into Python](http://www.diveintopython.net/)
-* [Официальная документация](http://docs.python.org/2.6/)
+* [Ideas for Python Projects](http://pythonpracticeprojects.com)
+* [Официальная документация](http://docs.python.org/3/)
 * [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
-* [Python Module of the Week](http://pymotw.com/2/)
+* [Python Module of the Week](http://pymotw.com/3/)
 * [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
 
 ### Платные
diff --git a/ru-ru/python3-ru.html.markdown b/ru-ru/pythonlegacy-ru.html.markdown
index bf80fed2..ead2af3d 100644
--- a/ru-ru/python3-ru.html.markdown
+++ b/ru-ru/pythonlegacy-ru.html.markdown
@@ -1,23 +1,23 @@
 ---
-language: python3
+language: Python 2 (legacy)
 lang: ru-ru
 contributors:
     - ["Louie Dinh", "http://ldinh.ca"]
-    - ["Steven Basart", "http://github.com/xksteven"]
 translators:
+    - ["Yury Timofeev", "http://twitter.com/gagar1n"]
     - ["Andre Polykanine", "https://github.com/Oire"]
-filename: learnpython3-ru.py
+filename: learnpythonlegacy-ru.py
 ---
 
 Язык Python был создан Гвидо ван Россумом в начале 90-х. Сейчас это один из
 самых популярных языков. Я влюбился в Python за понятный и доходчивый синтаксис  — это
-почти что исполняемый псевдокод.
+почти исполняемый псевдокод.
 
 С благодарностью жду ваших отзывов: [@louiedinh](http://twitter.com/louiedinh)
 или louiedinh [at] [почтовый сервис Google]
 
-Замечание: Эта статья относится только к Python 3.
-Если вы хотите изучить Python 2.7, обратитесь к другой статье.
+Замечание: Эта статья относится к Python 2.7, но должно работать и в других версиях Python 2.x.
+Чтобы изучить Python 3.x, обратитесь к статье по Python 3.
 
 ```python
 # Однострочные комментарии начинаются с символа решётки.
@@ -37,9 +37,16 @@ filename: learnpython3-ru.py
 1 + 1 #=> 2
 8 - 1 #=> 7
 10 * 2 #=> 20
+35 / 5 #=> 7
 
-# Кроме деления, которое по умолчанию возвращает число с плавающей запятой
-35 / 5  # => 7.0
+# А вот деление немного сложнее. В этом случае происходит деление 
+# целых чисел, и результат автоматически округляется в меньшую сторону.
+5 / 2 #=> 2
+
+# Чтобы делить правильно, сначала нужно немного узнать о числах
+# с плавающей запятой.
+2.0     # Это число с плавающей запятой
+11.0 / 4.0 #=> 2.75 Вооот... Так гораздо лучше
 
 # Результат целочисленного деления округляется в меньшую сторону
 # как для положительных, так и для отрицательных чисел.
@@ -48,10 +55,6 @@ filename: learnpython3-ru.py
 -5 // 3  # => -2
 -5.0 // 3.0 # => -2.0
 
-# Когда вы используете числа с плавающей запятой, 
-# результатом будет также число с плавающей запятой
-3 * 2.0 # => 6.0
-
 # Остаток от деления
 7 % 3 # => 1
 
@@ -61,14 +64,6 @@ filename: learnpython3-ru.py
 # Приоритет операций указывается скобками
 (1 + 3) * 2 #=> 8
 
-# Для логических (булевых) значений существует отдельный примитивный тип
-True
-False
-
-# Для отрицания используется ключевое слово not
-not True #=> False
-not False #=> True
-
 # Логические операторы
 # Обратите внимание: ключевые слова «and» и «or» чувствительны к регистру букв
 True and False #=> False
@@ -81,6 +76,10 @@ False or True #=> True
 2 == True #=> False
 1 == True #=> True
 
+# Для отрицания используется ключевое слово not
+not True #=> False
+not False #=> True
+
 # Равенство — это ==
 1 == 1 #=> True
 2 == 1 #=> False
@@ -95,7 +94,7 @@ False or True #=> True
 2 <= 2 #=> True
 2 >= 2 #=> True
 
-# Сравнения могут быть записаны цепочкой:
+# Сравнения могут быть записаны цепочкой!
 1 < 2 < 3 #=> True
 2 < 3 < 2 #=> False
 
@@ -103,70 +102,75 @@ False or True #=> True
 "Это строка."
 'Это тоже строка.'
 
-# И строки тоже могут складываться! Хотя лучше не злоупотребляйте этим.
+# И строки тоже можно складывать!
 "Привет " + "мир!" #=> "Привет мир!"
 
-# Строки можно умножать.
-"aa" * 4 #=> "aaaaaaaa"
+# ... или умножать
+"Привет" * 3  # => "ПриветПриветПривет"
 
 # Со строкой можно работать, как со списком символов
 "Это строка"[0] #=> 'Э'
 
-# Метод format используется для форматирования строк:
+# Символ % используется для форматирования строк, например:
+"%s могут быть %s" % ("строки", "интерполированы")
+
+# Новый способ форматирования строк — использование метода format.
+# Это предпочитаемый способ.
 "{0} могут быть {1}".format("строки", "форматированы")
 
-# Вы можете повторять аргументы форматирования, чтобы меньше печатать.
-"Ехал {0} через реку, видит {0} - в реке {1}! Сунул {0} руку в реку, {1} за руку греку цап!".format("грека", "рак")
-#=> "Ехал грека через реку, видит грека - в реке рак! Сунул грека руку в реку, рак за руку греку цап!"
 # Если вы не хотите считать, можете использовать ключевые слова.
 "{name} хочет есть {food}".format(name="Боб", food="лазанью")
 
-# Если ваш код на Python 3 нужно запускать также и под Python 2.5 и ниже,
-# вы также можете использовать старый способ форматирования:
-"%s можно %s %s способом" % ("строки", "интерполировать", "старым")
-
 # None является объектом
 None #=> None
 
-# Не используйте оператор равенства '==' для сравнения 
-# объектов с None. Используйте для этого 'is'
+# Не используйте оператор равенства '=='' для сравнения 
+# объектов с None. Используйте для этого «is»
 "etc" is None #=> False
 None is None  #=> True
 
-# Оператор «is» проверяет идентичность объектов. Он не 
+# Оператор 'is' проверяет идентичность объектов. Он не 
 # очень полезен при работе с примитивными типами, но 
 # зато просто незаменим при работе с объектами.
 
-# None, 0 и пустые строки/списки/словари приводятся к False.
+# None, 0 и пустые строки/списки равны False.
 # Все остальные значения равны True
-bool(0)  # => False
-bool("")  # => False
-bool([]) #=> False
-bool({}) #=> False
+0 == False  #=> True
+"" == False #=> True
 
 
 ####################################################
 ## 2. Переменные и коллекции
 ####################################################
 
-# В Python есть функция Print
-print("Я Python. Приятно познакомиться!")
+# В Python есть оператор print, доступный в версиях 2.x, но удалённый в версии 3
+print "Я Python. Приятно познакомиться!"
+# В Python также есть функция print(), доступная в версиях 2.7 и 3,
+# Но для версии 2.7 нужно добавить следующий импорт модуля (раскомментируйте)):
+# from __future__ import print_function
+print("Я тоже Python! ")
 
 # Объявлять переменные перед инициализацией не нужно.
-# По соглашению используется нижний_регистр_с_подчёркиваниями
-some_var = 5
+some_var = 5    # По соглашению используется нижний_регистр_с_подчёркиваниями
 some_var #=> 5
 
 # При попытке доступа к неинициализированной переменной
 # выбрасывается исключение.
-# Об исключениях см. раздел «Поток управления и итерируемые объекты».
-some_unknown_var  # Выбрасывает ошибку именования
+# См. раздел «Поток управления» для информации об исключениях.
+some_other_var  # Выбрасывает ошибку именования
+
+# if может быть использован как выражение
+"yahoo!" if 3 > 2 else 2 #=> "yahoo!"
 
 # Списки хранят последовательности
 li = []
 # Можно сразу начать с заполненного списка
 other_li = [4, 5, 6]
 
+# строка разделена в список
+a="adambard"
+list(a) #=> ['a','d','a','m','b','a','r','d']
+
 # Объекты добавляются в конец списка методом append
 li.append(1)    # [1]
 li.append(2)    # [1, 2]
@@ -179,6 +183,10 @@ li.append(3)    # [1, 2, 4, 3].
 
 # Обращайтесь со списком, как с обычным массивом
 li[0] #=> 1
+# Присваивайте новые значения уже инициализированным индексам с помощью =
+li[0] = 42
+li[0]  # => 42
+li[0] = 1  # Обратите внимание: возвращаемся на исходное значение
 # Обратимся к последнему элементу
 li[-1] #=> 3
 
@@ -200,11 +208,11 @@ li[::-1]   # => [3, 4, 2, 1]
 # li[начало:конец:шаг]
 
 # Удаляем произвольные элементы из списка оператором del
-del li[2] # [1, 2, 3]
+del li[2] # li теперь [1, 2, 3]
 
 # Вы можете складывать, или, как ещё говорят, конкатенировать списки
-# Обратите внимание: значения li и other_li при этом не изменились.
 li + other_li #=> [1, 2, 3, 4, 5, 6]  — Замечание: li и other_li не изменяются
+# Обратите внимание: значения li и other_li при этом не изменились.
 
 # Объединять списки можно методом extend
 li.extend(other_li) # Теперь li содержит [1, 2, 3, 4, 5, 6]
@@ -234,7 +242,6 @@ d, e, f = 4, 5, 6
 # Обратите внимание, как легко поменять местами значения двух переменных
 e, d = d, e     # теперь d == 5, а e == 4
 
-
 #  Словари содержат ассоциативные массивы
 empty_dict = {}
 # Вот так описывается предзаполненный словарь
@@ -244,17 +251,13 @@ filled_dict = {"one": 1, "two": 2, "three": 3}
 # что индекс — у словарей он называется ключом — не обязан быть числом
 filled_dict["one"] #=> 1
 
-# Все ключи в виде списка получаются с помощью метода keys(). 
-# Его вызов нужно обернуть в list(), так как обратно мы получаем
-# итерируемый объект, о которых поговорим позднее.
-list(filled_dict.keys())   # => ["three", "two", "one"]
+# Можно получить все ключи в виде списка с помощью метода keys
+filled_dict.keys() #=> ["three", "two", "one"]
 # Замечание: сохранение порядка ключей в словаре не гарантируется
 # Ваши результаты могут не совпадать с этими.
 
-# Все значения в виде списка можно получить с помощью values().
-# И снова нам нужно обернуть вызов в list(), чтобы превратить
-# итерируемый объект в список.
-list(filled_dict.values())   # => [3, 2, 1]
+# Можно получить и все значения в виде списка, используйте метод values
+filled_dict.values() #=> [3, 2, 1]
 # То же самое замечание насчёт порядка ключей справедливо и здесь
 
 # При помощи оператора in можно проверять ключи на вхождение в словарь
@@ -271,27 +274,28 @@ filled_dict.get("four") #=> None
 # возвращено при отсутствии указанного ключа
 filled_dict.get("one", 4) #=> 1
 filled_dict.get("four", 4) #=> 4
+# Обратите внимание, что filled_dict.get("four") всё ещё => None
+# (get не устанавливает значение элемента словаря)
+
+# Присваивайте значение ключам так же, как и в списках
+filled_dict["four"] = 4  # теперь filled_dict["four"] => 4
 
-# Метод setdefault вставляет пару ключ-значение, только если такого ключа нет
+# Метод setdefault() вставляет пару ключ-значение, только если такого ключа нет
 filled_dict.setdefault("five", 5) #filled_dict["five"] возвращает 5
 filled_dict.setdefault("five", 6) #filled_dict["five"] по-прежнему возвращает 5
 
-# Добавление элементов в словарь
-filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4}
-#filled_dict["four"] = 4  # Другой способ добавления элементов
-
-# Удаляйте ключи из словаря с помощью оператора del
-del filled_dict["one"]  # Удаляет ключ «one» из словаря
-
 
 # Множества содержат... ну, в общем, множества
+# (которые похожи на списки, только в них не может быть дублирующихся элементов)
 empty_set = set()
-# Инициализация множества набором значений.
-# Да, оно выглядит примерно как словарь… ну извините, так уж вышло.
-filled_set = {1, 2, 2, 3, 4} # => {1, 2, 3, 4}
+# Инициализация множества набором значений
+some_set = set([1,2,2,3,4]) # some_set теперь равно set([1, 2, 3, 4])
 
-# Множеству можно назначать новую переменную
-filled_set = some_set
+# Порядок сортировки не гарантируется, хотя иногда они выглядят отсортированными
+another_set = set([4, 3, 2, 2, 1])  # another_set теперь set([1, 2, 3, 4])
+
+# Начиная с Python 2.7, вы можете использовать {}, чтобы объявить множество
+filled_set = {1, 2, 2, 3, 4} # => {1, 2, 3, 4}
 
 # Добавление новых элементов в множество
 filled_set.add(5) # filled_set равно {1, 2, 3, 4, 5}
@@ -312,7 +316,7 @@ filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
 
 
 ####################################################
-## 3. Поток управления и итерируемые объекты
+## 3. Поток управления
 ####################################################
 
 # Для начала заведём переменную
@@ -328,13 +332,17 @@ else:           # Это тоже необязательно.
     print("some_var равно 10.")
 
 
-# Циклы For проходят по спискам. Результат:
-    # собака — это млекопитающее
-    # кошка — это млекопитающее
-    # мышь — это млекопитающее
+"""
+Циклы For проходят по спискам
+
+Результат:
+    собака — это млекопитающее
+    кошка — это млекопитающее
+    мышь — это млекопитающее
+"""
 for animal in ["собака", "кошка", "мышь"]:
-    # Можете использовать format() для интерполяции форматированных строк
-    print("{} — это млекопитающее".format(animal))
+    # Можете использовать оператор % для интерполяции форматированных строк
+    print("%s — это млекопитающее" % animal)
     
 """
 «range(число)» возвращает список чисел
@@ -362,6 +370,8 @@ while x < 4:
     x += 1  # Краткая запись для x = x + 1
 
 # Обрабатывайте исключения блоками try/except
+
+# Работает в Python 2.6 и выше:
 try:
     # Чтобы выбросить ошибку, используется raise
     raise IndexError("Это ошибка индекса")
@@ -374,37 +384,6 @@ except (TypeError, NameError):
 else:   # Необязательное выражение. Должно следовать за последним блоком except
     print("Всё хорошо!")   # Выполнится, только если не было никаких исключений
 
-# Python предоставляет фундаментальную абстракцию,
-# которая называется итерируемым объектом (an iterable).
-# Итерируемый объект — это объект, который воспринимается как последовательность.
-# Объект, который возвратила функция range(), итерируемый.
-filled_dict = {"one": 1, "two": 2, "three": 3}
-our_iterable = filled_dict.keys()
-print(our_iterable) #=> range(1,10). Это объект, реализующий интерфейс iterable
-
-# Мы можем проходить по нему циклом.
-for i in our_iterable:
-    print(i)    # Выводит one, two, three
-
-# Но мы не можем обращаться к элементу по индексу.
-our_iterable[1]  # Выбрасывает ошибку типа
-
-# Итерируемый объект знает, как создавать итератор.
-our_iterator = iter(our_iterable)
-
-# Итератор может запоминать состояние при проходе по объекту.
-# Мы получаем следующий объект, вызывая функцию __next__.
-our_iterator.__next__()  #=> "one"
-
-# Он сохраняет состояние при вызове __next__.
-our_iterator.__next__()  #=> "two"
-our_iterator.__next__()  #=> "three"
-
-# Возвратив все данные, итератор выбрасывает исключение StopIterator
-our_iterator.__next__() # Выбрасывает исключение остановки итератора
-
-# Вы можете получить сразу все элементы итератора, вызвав на нём функцию list().
-list(filled_dict.keys())  #=> Возвращает ["one", "two", "three"]
 
 
 ####################################################
@@ -422,7 +401,8 @@ add(5, 6) #=> выводит «x равен 5, а y равен 6» и возвр
 # Другой способ вызова функции — вызов с именованными аргументами
 add(y=6, x=5)   # Именованные аргументы можно указывать в любом порядке.
 
-# Вы можете определить функцию, принимающую переменное число аргументов
+# Вы можете определить функцию, принимающую переменное число аргументов,
+# которые будут интерпретированы как кортеж, если вы не используете *
 def varargs(*args):
     return args
 
@@ -430,7 +410,8 @@ varargs(1, 2, 3) #=> (1,2,3)
 
 
 # А также можете определить функцию, принимающую переменное число
-# именованных аргументов
+# именованных аргументов, которые будут интерпретированы как словарь,
+# если вы не используете **
 def keyword_args(**kwargs):
     return kwargs
 
@@ -455,6 +436,14 @@ all_the_args(*args) # эквивалентно foo(1, 2, 3, 4)
 all_the_args(**kwargs) # эквивалентно foo(a=3, b=4)
 all_the_args(*args, **kwargs) # эквивалентно foo(1, 2, 3, 4, a=3, b=4)
 
+# вы можете передавать переменное число позиционных или именованных аргументов
+# другим функциям, которые их принимают, распаковывая их с помощью
+# * или ** соответственно
+def pass_all_the_args(*args, **kwargs):
+    all_the_args(*args, **kwargs)
+    print varargs(*args)
+    print keyword_args(**kwargs)
+
 # Область определения функций
 x = 5
 
@@ -513,7 +502,7 @@ class Human(object):
 
     # Метод экземпляра. Все методы принимают self в качестве первого аргумента
     def say(self, msg):
-        return "{name}: {message}".format(name=self.name, message=msg)
+       return "%s: %s" % (self.name, msg)
 
     # Метод класса разделяется между всеми экземплярами
     # Они вызываются с указыванием вызывающего класса в качестве первого аргумента
@@ -566,6 +555,9 @@ from math import *
 # Можете сокращать имена модулей
 import math as m
 math.sqrt(16) == m.sqrt(16) #=> True
+# Вы также можете убедиться, что функции эквивалентны
+from math import sqrt
+math.sqrt == m.sqrt == sqrt  # => True
 
 # Модули в Python — это обычные Python-файлы. Вы
 # можете писать свои модули и импортировать их. Название
@@ -589,14 +581,15 @@ def double_numbers(iterable):
 # Он не возвращает все значения разом, а создаёт каждое из них при каждой
 # итерации.  Это значит, что значения больше 15 в double_numbers
 # обработаны не будут.
-# Обратите внимание: range — это тоже генератор.
+# Обратите внимание: xrange — это генератор, который делает то же, что и range.
 # Создание списка чисел от 1 до 900000000 требует много места и времени.
+# xrange создаёт объект генератора, а не список сразу, как это делает range.
 # Если нам нужно имя переменной, совпадающее с ключевым словом Python,
 # мы используем подчёркивание в конце
-range_ = range(1, 900000000)
+xrange_ = xrange(1, 900000000)
 
 # Будет удваивать все числа, пока результат не превысит 30
-for i in double_numbers(range_):
+for i in double_numbers(xrange_):
     print(i)
     if i >= 30:
         break
@@ -637,10 +630,9 @@ print(say(say_please=True)) # Вы не купите мне пива? Пожал
 
 * [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
 * [Dive Into Python](http://www.diveintopython.net/)
-* [Ideas for Python Projects](http://pythonpracticeprojects.com)
-* [Официальная документация](http://docs.python.org/3/)
+* [Официальная документация](http://docs.python.org/2.6/)
 * [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
-* [Python Module of the Week](http://pymotw.com/3/)
+* [Python Module of the Week](http://pymotw.com/2/)
 * [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
 
 ### Платные