Serg Iakovlev

Эта глава описывает одну из самых сильных возможностей языка Python — самоанализ. Ка вы уже знаете, все в языке Python является объектами. Самоанализ — использование специального кода для просмотра в памяти модулей и функций как объектов, извлекая информацию о них и о том, как их использовать. По ходу мы будем определять функции без имени, передавать аргументы в неправильном порядке и использовать функции, имена которых до этого даже не знали.

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

Пример 2.1. apihelper.py


 def help(object, spacing=10, collapse=1):   
     """Выводит методы и строки документации.
     
     В качестве аргумента может использоваться модуль, класс, список, словарь
     или строка."""
     methodList = [method for method in dir(object) if callable(getattr(object, method))]
     processFunc = collapse and (lambda s: " ".join(s.split())) or (lambda s: s)
     print "\n".join(["%s %s" %
                       (method.ljust(spacing),
                        processFunc(str(getattr(object, method).__doc__)))
                      for method in methodList])
 
 if __name__ == "__main__":                 
     print help.__doc__

	Этот модуль определяет одну функцию — `help`. Она воспринимает три аргумента: `object`, `spacing` и `collapse`. Последние два аргумента, как мы скоро увидим, не являются обязательными.
	Функция `help` имеет многострочную строку документации, кратко описывающую предназначение функции. Обратите внимание, что здесь не упомянуто возвращаемое значение — функция предназначениа для выполнения определенных действий а не возврата значения.
	Тело функции выделено отступами.
	Прием с `if __name__` позволяет использовать модуль в качестве программы без каких-либо конфликтов. В данном случае программа просто выводит строку документации функции `help`.
	В инструкции `if` для сравнения используется оператор `==`. Заключать в скобки выражение совсем не обязательно.

Функция help предназначена для использования программистом при работе в Python IDE. В качестве аргумента можно использовать любой объект, имеющий функции (например, модуль) или методы (например, список). Эта функция выводит имена функций (или метододов) объекта и их строки документации.

Пример 2.2. Использование apihelper.py

>>> from apihelper import help
 >>> li = []
 >>> help(li)
 append     L.append(object) -- append object to end
 count      L.count(value) -> integer -- return number of occurrences of value
 extend     L.extend(list) -- extend list by appending list elements
 index      L.index(value) -> integer -- return index of first occurrence of value
 insert     L.insert(index, object) -- insert object before index
 pop        L.pop([index]) -> item -- remove and return item at index (default last)
 remove     L.remove(value) -- remove first occurrence of value
 reverse    L.reverse() -- reverse *IN PLACE*
 sort       L.sort([cmpfunc]) -- sort *IN PLACE*; if given, cmpfunc(x, y) -> -1, 0, 1

По умолчанию информация выводится в легко воспринимаемом виде. Многострочные строки документации преобразуются в одну длинную строку, но это особенность можно отключить, передав 0 в качестве аргумента collapse. Кроме того, если имена функций содержат 10 символов, вы можете установить большее значение аргумента spacing.

Пример 2.3. Дополнительные возможности apihelper.py

>>> import odbchelper
 >>> help(odbchelper)
 buildConnectionString Build a connection string from a dictionary Returns string.
 >>> help(odbchelper, 30)
 buildConnectionString          Build a connection string from a dictionary Returns string.
 >>> help(odbchelper, 30, 0)
 buildConnectionString          Build a connection string from a dictionary
 Returns string.

В языке Python аргументы функции могут иметь значения по умолчанию, оно будет использовано, если при вызове функции значение этого аргумента не указано. Более того, аргументы имеющие значение по умолчанию при вызове могут быть указаны в произвольном порядке, если указано имя аргумента. В хранимых процедурах для SQL сервера Transact/SQL также могут быть использованы именованные аргументы; если вы пишите сценарии для SQL сервера, можете лишь бегло ознакомиться с этим разделом.

Пример 2.4. help — функция с двумя необязательными аргументами


 def help(object, spacing=10, collapse=1):

Аргументы spacing и collapse могут быть опущены при вызове, так как для них определены значения по умолчанию. Аргумент object не имеет значения по умолчанию, поэтому должен быть указан всегда. Если функция help вызывается только с одним аргументом, то spacing принимает значение 10 и collapse принимает значение 1. Если help вызывается с двумя аргументами, collapse также принимает значение 1.

Представьте теперь, что вы хотите указать значение аргумента collapse, но использовать значение по умолчанию для spacing. В большинстве языков вам придется передавать все три аргумента. Однако Python позволяет передавать аргументы в произвольном порядке по имени.

Пример 2.5. Возможные способы вызова help

help(odbchelper)                    
 help(odbchelper, 12)                
 help(odbchelper, collapse=0)        
 help(spacing=15, object=odbchelper)

	С одним аргументом, `spacing` и `collapse` получают значения по умолчанию, `10` и `1` соответственно.
	С двумя аргументами, `collapse` получает значение по умолчанию `1`.
	Здесь вы явно указываете имя аргумента, `collapse`, для которого передается значение. Аргумент `spacing` по-прежнему получает значение по умолчанию `10`.
	Даже обязательные аргументы (в данном случае — `object`), которые не имеют значения по умолчанию, могут быть переданы по имени, и именованные аргументы могут быть указаны в произвольном порядке.

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

В языке Python есть небольшой набор очень полезных встроенных функций. Все остальные функции распределены по модулям. В самом деле, это удачное проектное решение позволяет предотвратить разбухание ядра языка, как это произошло с некоторыми другими скриптовыми языками (например, Visual Basic).

Функция type возвращает тип произвольного объекта. Возможные значения типов перечислены в модуле types. Определение типа полезно в функциях, способных обрабатывать данные нескольких типов.

Пример 2.6. Функция type

>>> type(1)           
 <type 'int'>
 >>> li = []
 >>> type(li)          
 <type 'list'>
 >>> import odbchelper
 >>> type(odbchelper)  
 <type 'module'>
 >>> import types      
 >>> type(odbchelper) == types.ModuleType
 1

	Функция `type` воспринимает объект произвольного типа и возвращает его тип. Аргумент действительно может быть произвольного типа: число, строка, список, словарь, кортеж, функция, класс, модуль и даже сам тип.
	В качестве аргумента может использоваться переменная.
	Функция `type` работает и c модулей.
	Вы можете использовать константы, определенные в модуле `types` для сравнения типов объектов. Именно это и делает, как мы скоро увидим, функция `help`.

Функция str преобразует данные в строку. Для любого типа данных можно получить строковое представление.

Пример 2.7. Функция str

>>> str(1)          
 '1'
 >>> horsemen = ['war', 'pestilence', 'famine']
 >>> horsemen.append('Powerbuilder')
 >>> str(horsemen)   
 "['war', 'pestilence', 'famine', 'Powerbuilder']"
 >>> str(odbchelper) 
 "<module 'odbchelper' from 'c:\\docbook\\dip\\py\\odbchelper.py'>"
 >>> str(None)       
 'None'

	Вы, наверное, ожидали, что `str` будет работать с такими простыми типами данных, как целые числа, так как почти каждый язык содержит функцию для преобразования целого числа в строку.
	Однако, `str` работает и с объектами других типов. В данном случае мы получаем строковое представление списка.
	Функция `str` работает и с модулями. Обратите внимание, что строковое представление модуля содержит путь к модулю на диске, так что в вашем случае он будет отличаться.
	Важно также, что `str` работает и с объектом `None`, “нулевым” значением в языке Python. В этом случае она возвращает строку `'None'`. Мы воспользуемся этим в функции `help`.

Сердцем функции help является мощная функция dir. dir возвращает список атрибутов и методов произвольного объекта: модуля, функции, строки, списка, словаря… в общем, любого объекта.

Пример 2.8. Функция dir

>>> li = []
 >>> dir(li)           
 ['append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
 >>> d = {}
 >>> dir(d)            
 ['clear', 'copy', 'get', 'has_key', 'items', 'keys', 'setdefault', 'update', 'values']
 >>> import odbchelper
 >>> dir(odbchelper)   
 ['__builtins__', '__doc__', '__file__', '__name__', 'buildConnectionString']

	`li` является списком, так что `dir(li)` дает список имен всех методов списка. Обратите внимание, что возвращаемый список содержит имена методов в виде строк, а не сами методы.
	`d` является словарем, поэтому `dir(d)` дает список имен методов словаря. Как минимум один из них, `keys`, вам уже знаком.
	Здесь начинается самое интересное. `odbchelper` является модулем, так что `dir(odbchelper)` дает список всех имен, определенных в модуле, включая специальные атрибуты, такие как `__name__` и `__doc__`. В данном случае, `odbchelper` содержит одну пользовательскую функцию, `buildConnectionString`, которую мы изучали в главе Знакомство с языком Python.

Наконец, функция callable возвращает 1, если аргумент может быть вызван, в противном случае возвращает 0. Вызов поддерживают такие объекты, как функции, методы и даже классы. (Более подробно о классах читайте в главе 3.)

Пример 2.9. Функция callable

>>> import string
 >>> string.punctuation           
 '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
 >>> string.join                  
 <function join at 00C55A7C>
 >>> callable(string.punctuation) 
 0
 >>> callable(string.join)        
 1
 >>> print string.join.__doc__    
 join(list [,sep]) -> string
 
     Return a string composed of the words in list, with
     intervening occurrences of sep.  The default separator is a
     single space.
 
     (joinfields and join are synonymous)

	На смену большинству функций модуля `string` пришли методов строк (хотя многие до сих пор используют функцию `join`), но модуль также содержит множество полезных констант. Например `string.punctuation` содержит все стандартные символы пунктуации.
	Функция `string.join` объединяет строки списка в одну строку.
	`string.punctuation` является строкой и вызов не поддерживает. (Строки имеют методы, которые можно вызвать, но вы не можете вызвать саму строку.)
	`string.join` ялвляется функцией и поддерживает вызов с двумя аргументами.
	Любой объект, поддерживающий вызов, может иметь строку документации. Применяя функцию `callable` к каждому атрибуту объекта, мы можем определить, какие атрибуты представляют для нас интерес (методы, функции, классы), и какие можно игнорировать (константы и т. д.), не имея каких-либо начальных знаний об объекте.

type, str, dir и другие втроенные функции языка Python сгруппированы в специальном модуле __builtin__ (обратите внимание на два символа подчеркивания в начале и два в конце). Встроенные функции доступны напрямую, как если бы интерпретатор при запуске автоматически выполнял from __builtin__ import *.

Вы можете получить информацию о встроенных функциях (и других объектах) как об отдельной группе исследуя модуль __builtin__. Для этих целей у нас есть функция help. Попробуйте проделать это сейчас сами. Позже мы более подробно рассмотрим наиболее важные встроенные функции (некоторые классы исключений, например AttributeError, вам должны быть уже знакомы.)

Пример 2.10. Втроенные функции и другие объекты

>>> from apihelper import help
 >>> import __builtin__
 >>> help(__builtin__, 20)
 ArithmeticError      Base class for arithmetic errors.
 AssertionError       Assertion failed.
 AttributeError       Attribute not found.
 EOFError             Read beyond end of file.
 EnvironmentError     Base class for I/O related errors.
 Exception            Common base class for all exceptions.
 FloatingPointError   Floating point operation failed.
 IOError              I/O operation failed.
 
 [... и т. д. ...]

Вы уже знаете, что функции в языке Python являются объектами. Но вы пока не знаете, что если имя функции становится известно только во время выполнения программы, то ее можно получить с помощью функции getattr.

Пример 2.11. Функция getattr

>>> li = ["Larry", "Curly"]
 >>> li.pop                       
 <built-in method pop of list object at 010DF884>
 >>> getattr(li, "pop")           
 <built-in method pop of list object at 010DF884>
 >>> getattr(li, "append")("Moe") 
 >>> li
 ["Larry", "Curly", "Moe"]
 >>> getattr({}, "clear")         
 <built-in method clear of dictionary object at 00F113D4>
 >>> getattr((), "pop")           
 Traceback (innermost last):
   File "<interactive input>", line 1, in ?
 AttributeError: 'tuple' object has no attribute 'pop'

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

Пример 2.12. getattr в apihelper.py

>>> import odbchelper
 >>> odbchelper.buildConnectionString             
 <function buildConnectionString at 00D18DD4>
 >>> getattr(odbchelper, "buildConnectionString") 
 <function buildConnectionString at 00D18DD4>
 >>> object = odbchelper
 >>> method = "buildConnectionString"
 >>> getattr(object, method)                      
 <function buildConnectionString at 00D18DD4>
 >>> type(getattr(object, method))                
 <type 'function'>
 >>> import types
 >>> type(getattr(object, method)) == types.FunctionType
 1
 >>> callable(getattr(object, method))            
 1

	Так мы можем получить функцию `buildConnectionString` из модуля `odbchelper`, который сы изучали в разделе Знакомство с языком Python. (Шестнадцатиричный адрес характерен для моей машины, у вас он будет другим.)
	Используя `getattr`, мы можем получить ту же самую функцию. В общем, `getattr(object, "attribute")` дает такой же результат, как `object.attribute`. Если `object` является модулем, `attribute` может быть любым объектом, определенном в этом модуле: функцией, классом или другой глобальной переменной.
	На самом деле именно это и делает функция `help`. `object` передается функции в качестве аргумента; `method` является строкой с именем метода или функции.
	В данном случае, `method` содержит имя функции, в чем мы можем убедиться получив ее тип.
	Так как `method` является функцией, ее можно вызвать.

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

Пример 2.13. Синтаксис фильтрования списков

[mapping-expression for element in source-list if filter-expression]

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

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

>>> li = ["a", "mpilgrim", "foo", "b", "c", "b", "d", "d"]
 >>> [elem for elem in li if len(elem) > 1]       
 ['mpilgrim', 'foo']
 >>> [elem for elem in li if elem != "b"]         
 ['a', 'mpilgrim', 'foo', 'c', 'd', 'd']
 >>> [elem for elem in li if li.count(elem) == 1] 
 ['a', 'mpilgrim', 'foo', 'c']

	В данном случае выражение отображения совсем простое (значение каждого элемента), так что сосредоточьтесь на условии фильтра. Каждый элемент пробегаемого списка Python пропускает через фильтр. Если условие фильтра дает истину, элемент участвует в преобразовании и результат включается в возвращаемый список. В данном случае мы исключили все строки длиной в один символ.
	Здесь мы исключаем элементы с одним определенным значением, `"b"`. Обратите внимание, что фильтром отбрасываются все элементы со значением `"b"`, так как во всех случаях выражение условия будет давать ложь.
	Метод `count` списка возвращает количество вхождений элементов определенного значения в список. Вы можете подумать, что этот фильтр исключает все дубликаты, и возвращаемый список будет содержать по одному значению исходного списка. Но это не так, потому что значения, входящие в исходный список дважды (в данном случае это, `"b"` and `"d"`) полностью исключаются. Существует множество способов исключить дубликаты из списка, но не так.

Пример 2.15. Фильтрование списка в apihelper.py

    methodList = [method for method in dir(object) if callable(getattr(object, method))]

Этот пример выглядит сложным, но основная структура остается прежней. Все выражение дает список, который присваивается переменной methodList. Выражение отображения простое: оно дает значение каждого элемента. Функция dir(object) возвращает список всех атрибутов и методов объекта object — это тот список, который мы преобразуем. И единственная новая часть — это условие фильтра после if.

Выражение фильтра выглядит жутко, но он таковым не является. Вы уже знаете о callable, getattr и in. Как вы могли видеть в предыдущем разделе, выражение getattr(object, method) дает объект-функцию, если object является модулем и method содержит имя функции из этого модуля.

Таким образом, мы берем объект object, получаем список имен его атрибутов, методов, функций, и затем фильтруем этот список, избавляясь от всего, что нас не интересует. Для того, чтобы избавиться от ненужного, мы берем имя каждого атрибута/метода/функции, с помощью функции getattr получаем настоящий объект. Затем мы проверяем, поддерживает ли объект вызов, таким образом подхватывая все функции и методы — как встроенные (например, метод pop списков), так и определенные пользователем (например, функция buildConnectionString в модуле odbchelper). Нас не интересуют другие атрибуты, такие как обязательный для всех моделей атрибут __name__.

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

Пример 2.16. Оператор and

>>> 'a' and 'b'         
 'b'
 >>> '' and 'b'          
 ''
 >>> 'a' and 'b' and 'c' 
 'c'

	При использовании оператора `and`, значения вычисляются в булевом контексте слева напрво. Значения `0`, `''`, `[]`, `()`, `{}` и `None` являются ложью, все остальное является истиной^[3]. Если у `and` оба операнда являются истиной, результатом будет последнее значение. В данном случае вычисляется выражение `'a'`, которое является истиной, затем `'b'`, которое также является истиной, и возвращается `'b'`.
	Если какой-либо из операндов является ложью, результатом будет первое такое значение. В данном случает `''` — первое значение, являющееся ложью.
	Все значения являются истиной, так что в результате мы получаем последнее — `'c'`.

Пример 2.17. Оператор or

>>> 'a' or 'b'          
 'a'
 >>> '' or 'b'           
 'b'
 >>> '' or [] or {}      
 {}
 >>> def sidefx():
 ...     print "in sidefx()"
 ...     return 1
 >>> 'a' or sidefx()     
 'a'

	Как и для `and` опреранды `or` вычисляются в булевском контексте слева направо. Если операнд является истиной, `or` немедленно возвращает результат. В данном случае `'a'` — первое истинное значение.
	`or` вычисляет выражение `''`, которое является ложью, затем `'b'`, которое является истиной, и возвращает `'b'`.
	Если все значения являются ложью, `or` возвращает последнее. `or` вычисляет `''` (ложь), `[]` (ложь), затем `{}` (ложь) и возвращает `{}`.
	Обратите внимание, что `or` вычисляет операнды до тех пор, пока не найдет истинное значение, остальное игнорируется. Это имеет значение, когда вычисление операнда дает сторонние эффекты. В данном случае функция `sidefx` не вызывается, так как для получения результата выражения с опереатором `or` достаточно того, что первый операнд, `'a'`, является истиной.

Если вы используете C, то, наверное, знакомы с выражением bool ? a : b, которое дает a, если bool является истиной, b, если bool ложно. Благодаря особенностям работы операторов and и or в Python, вы можете достигнуть анологичного эффекта.

Пример 2.18. Прием с and-or

>>> a = "first"
 >>> b = "second"
 >>> 1 and a or b 
 'first'
 >>> 0 and a or b 
 'second'

	Синтаксис `bool ? a : b` в языке Python выглядит похоже. Все выражение вычисляется слева направо, так что оператор `and` применяется первым. `1 and 'first'` дает `'first'`, затем `'first' or 'second'` дает `'first'`.
	`0 and 'first'` дает `0`, тогда `0 or 'second'` дает `'second'`.

Однако, так как такое выражение выполняет обычные логические операции, а не является специальной конструкцией языка, существует очень важная разница между приемом с and-or в языке Python и конструкцией bool ? a : b в C. Если значение a является ложью, это прием не будет работать так как вы могли ожидать. (Вы можете сказать, что обожгись на этом? Более одного раза?)

Пример 2.19. Когда прием с and-or не работает

>>> a = ""
 >>> b = "second"
 >>> 1 and a or b 
 'second'

Так как a — пустая строка, которую Python считает ложью в булевом контексте, 1 and '' дает '', а '' or 'second' дает 'second'. Ой! Это не то, что мы хотели получить.

Для безопасного использования приема с and-or необходимо сделать так, чтобы a всегда было истинным. Один из самых распространенных способо это сделать — заменить a на [a] и b на [b], тогда первый элемент получаемого списка будет либо a, либо b.

Пример 2.20. Безопасное использование приема с and-or

>>> a = ""
 >>> b = "second"
 >>> (1 and [a] or [b])[0] 
 ''

Так как выражение [a] является непустым списком, оно никогда не будет ложно. Даже если a равно 0, '' или другому значению, являющемуся ложью, список [a] всегда будет являться истиной, потому что содержит один элемент.

Кажется, этот прием не стоит того, чтобы его использовать. В конце концов вы всегда можете воспользоваться интсрукцией if. Тогда зачем вся эта суета? Конечно, в большинстве случаев выбирая между двумя константами вы можете использовать простой синтаксис и не беспокоиться, потому что значение a всегда будет истинным. И даже если придется использовать более сложный синтакс, на это могут найтись весские причины: в некоторых случаях в языке Python использование инструкции if не допускается, например в lambda-функциях.

Footnotes

^[3]Ну, почти все. По умолчанию экземпляры классов являются истиной, но вы можете определить специальные методы в классе, чтобы его экземпляры могли быть ложью. Вы узнаете все о классах и специальных методах в главе 3.

Пример 2.21. lambda-функции

>>> def f(x):
 ...     return x*2
 ...     
 >>> f(3)
 6
 >>> g = lambda x: x*2  
 >>> g(3)
 6
 >>> (lambda x: x*2)(3) 
 6

Эта lambda-функция делает то же самое, что и обычная функция, определенная выше. Обратите внимание на сокращенный синтаксис: список аргументов записывается без скобок и ключевое слово return отсутствует (оно подразумевается, так как тело функции может содержать только одно выражение). Кроме того, функция не имеет имени, но может быть вызвана через переменную, которой она присвоена.

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

Обобщая, lambda-функция — это функция, которая имеет произвольное число аргументов (включая необязательные аргументы) и возвращает значение одного выражения. lambda-функции не могут содержать инструкций или более одного выражения. Не пытайтесь втискивать в lambda-функцию слишком много. Если вам необходимл что-либо более сложное — определите обычную функцию.

Пример 2.22. lambda-функции в apihelper.py

    processFunc = collapse and (lambda s: " ".join(s.split())) or (lambda s: s)

Здесь следует обратить внимание на несколько вещей. Во-первых, мы используем простую форму приема с and-or. В данном случае это оправданно, так как lambda-функция всегда является истиной в булевом контексте (но это не означает, что lambda-функция не может возвращать значение, являющееся ложью; функция всегда является истиной, не зависимо от возвращаемого значения).

Во-вторых, мы используем метод split без аргументов. Вы уже видели его использование с одним и двумя аргументами, без аргументов метод split разбивает строку по символам пропуска (пробел, табуляция, возврат коретки, переход на новую строку).

Пример 2.23. split без аргументов

>>> s = "this   is\na\ttest"  
 >>> print s
 this   is
 a	test
 >>> print s.split()           
 ['this', 'is', 'a', 'test']
 >>> print " ".join(s.split()) 
 'this is a test'

	Это строка, которая содержит символ переход на новую строку, записанный в виде специальной последовательности (такие строки могут быть также записаны с использованием утроенных кавычек). `\n` — переход на новую строку, `\t` — символ горизонтальной табуляции.
	Метод `split` без аргументов разбивает строку по символам пропуска. В данном случае три пробела, переход на новую строку и табуляция воспринимаются одинаково.
	Вы можете нормализовать пропуски разбив строку, а затем снова объединив ее, используя один пробул в качестве разделителя. Именно это делает функция `help` для того, чтобы свернуть строку документации.

Так что же на самом деле делает функция help с этими lambda-функциями, методами split и приемом с and-or?

Пример 2.24. Присваивание функции переменной

    processFunc = collapse and (lambda s: " ".join(s.split())) or (lambda s: s)

processFunc теперь ссылается на функцию, но на какую — это зависит от значения переменной collapse. Если collapse является истиной, processFunc(string) будет сворачивать символы пропуска, в противном случае processFunc(string) будет возвращать аргумент без изменений.

Для того, чтобы сделать это на менее мощном языке, например на Visual Basic, вы, скорее всего, будете использовать интсрукцию if, чтобы решить, сворачивать символы пропуска или нет. Такой подход неэффективен, так как проверять условие придется при каждом вызове функции. В языке Python вы можете принять решение один раз и определить lambda-функцию, которая будет делать только то, что вам нужно.

Дополнительная литература

Python Knowledge Base описывает использование lambda для косвенного вызова функций.
Python Tutorial показывает, как получить доступ к внешним переменным из lambda-функции (PEP 227 поясняет, что в будущих версиях Python это будет сделать проще).
В The Whole Python FAQ приводятся примеры сбивающих с толку однострочных lambda-функций.

Пример 2.25. Основная часть apihelper.py

    print "\n".join(["%s %s" %
                       (method.ljust(spacing),
                        processFunc(str(getattr(object, method).__doc__)))
                      for method in methodList])

Обратите внимание, что это одна команда разбитая на несколько строк без явного использования признака продолжения (“\”). Помните, я говорил, что некоторые выражения могут быть записаны в несколько строк без использования обратного слэша? Расширенная запись списков — один из таких случаев, так как все выражение заключено в квадратные скобки.

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

Пример 2.26. Динамическое извлечение строки документации

>>> import odbchelper
 >>> object = odbchelper                   
 >>> method = 'buildConnectionString'      
 >>> getattr(object, method)               
 <function buildConnectionString at 010D6D74>
 >>> print getattr(object, method).__doc__ 
 Создает и возвращает строку соединения из словаря параметров.

	В функцию `help` `object` — объект, для которого мы хотим получить помощь — передается в качестве аргумента.
	По ходу того, как мы пробегаем по списку `methodList`, `method` содержит имя текущего метода.
	С помощью функции `getattr` мы получаем сам метод `method` объекта `object`.
	Теперь осталось самое простое — распечатать строку документации метода.

Следующий кирпичик — использование функции str. Как вы уже знаете, str — встроенная функция, перобразующая объект к строке. Но строка документации уже является строкой, так зачем же суетиться с использованием функции str? На самом деле не каждая функция имеет строку документации, и если строки документации нет, ее атрибут __doc__ равен None.

Пример 2.27. Зачем использовать str для строк документации?

>>> {}.keys.__doc__         
 >>> {}.keys.__doc__ == None 
 1
 >>> str({}.keys.__doc__)    
 'None'

	Метод `keys` словаря не имеет строки документации, так что его атрибут `__doc__` равен `None`. Если вы набираете выражение для атрибута `__doc__` непосредственно в интерактивном режиме, интерпретатор Python ничего не выводит, что может сбить с толку (такое поведение интерпретатора действительно удобно, если впомнить о процедурах, которые в языке Python возвращают `None`).
	Вы можете убедиться, что атрибут `__doc__` действительно равен `None` простым сравнением.
	Функция `str` возвращает строковое представление объекта, в данном случае `'None'`.

Теперь, когда мы уверены в том, что значение всегда будет строковым, можно передать его ранее определенной функции processFunc, которая сворачивает символы пропуска или возвращает строку без изменений. Теперь вы видите, почему важно использовать функцию str для преобразования None к строке. processFunc считает, что ее аргумент является строкой и вызывает его метод split. При попытке вызвать processFunc для None будет сгенерировано исключение, так как у None нет метода split.

Далее мы снова используем форматирование, чтобы соединить значение, возвращаемое функцией processFunc, со результатом применения метода ljust к строке method. Это новый метод строковых объектов, который мы раньше не видели.

Пример 2.28. Метод ljust

>>> s = 'buildConnectionString'
 >>> s.ljust(30) 
 'buildConnectionString         '
 >>> s.ljust(20) 
 'buildConnectionString'

	`ljust` дополняет строку пробелами до указанной длины. Именно это делает функция `help` при выводе в две колонки для выравнивания строк документации во второй колонке.
	Если требуемая длина меньше, чем исходная длина строки, `ljust` вернет строку без изменений. Этот метод никогда не обрезает строку.

Ну вот и почти все сделано. Имея метод ljust, дополняющий имя метода пробелами до нужной длины, и строку документации (возможно со свернутыми символами пропуска), которую возвращает processFunc, мы объединяем их и получаем одну строку. Так как мы пробегаем по списку methodList, то получим список строк. Используя метод join строки "\n", мы объединяем строки в одну с символом перехода на новую строку в качестве разделителя и печатаем результат.

Пример 2.29. Печать списка

>>> li = ['a', 'b', 'c']
 >>> print "\n".join(li) 
 a
 b
 c

Этот прием также будет будет полезен при отладке для вывода списков. А в языке Python вы будете работать со списками постоянно.

Пример 2.30. Основная часть apihelper.py, пересмотренная

    print "\n".join(["%s %s" %
                       (method.ljust(spacing),
                        processFunc(str(getattr(object, method).__doc__)))
                      for method in methodList])

Пример 2.31. apihelper.py


 def help(object, spacing=10, collapse=1):
     """Выводит методы и строки документации.
     
     В качестве аргумента может использоваться модуль, класс, список, словарь
     или строка."""
     methodList = [method for method in dir(object) if callable(getattr(object, method))]
     processFunc = collapse and (lambda s: " ".join(s.split())) or (lambda s: s)
     print "\n".join(["%s %s" %
                       (method.ljust(spacing),
                        processFunc(str(getattr(object, method).__doc__)))
                      for method in methodList])
 
 if __name__ == "__main__":
     print help.__doc__

Пример 2.32. Вывод apihelper.py

>>> from apihelper import help
 >>> li = []
 >>> help(li)
 append     L.append(object) -- append object to end
 count      L.count(value) -> integer -- return number of occurrences of value
 extend     L.extend(list) -- extend list by appending list elements
 index      L.index(value) -> integer -- return index of first occurrence of value
 insert     L.insert(index, object) -- insert object before index
 pop        L.pop([index]) -> item -- remove and return item at index (default last)
 remove     L.remove(value) -- remove first occurrence of value
 reverse    L.reverse() -- reverse *IN PLACE*
 sort       L.sort([cmpfunc]) -- sort *IN PLACE*; if given, cmpfunc(x, y) -> -1, 0, 1

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

Определение и вызов функций с необязательными и именованными аргументами
Использование функции str для получения строкового представления произвольного объекта
Использование функции getattr для динамического доступа к атрибутам
Использование расширенной записи списков для фильтрования
Распозновани приема с and-or и его безопасное использование
Определение lambda-функций
Присваивание функций переменным и использование этой переменной для вызова. Понимание этого приема жизнено необходимо для понимания языка Python. В книге вы увидите более сложные приложения этой концепции.

Вглубь языка Python - часть 2