Поиск по блогу

суббота, 1 ноября 2014 г.

Сначала надо получить список атрибутов dir(), а потом вытащить строки в тройных кавычках при помощи help()

Сначала командой dir() распечатываем список атрибутов объектов. Потом функцией help(), или .__doc__ вытаскиваем строки комментариев из атрибута (или) объекта. Help() - это обертка __doc__? Следует помнить также, что функция help может извлекать информацию не только из встроенных, но и из любых других модулей (в том числе - моих).

Кроме того, обычно отдельно online поставляется подробная документация в HTML формате - это документация, которую мы читаем обычно на сайте (но устаревшая). Еу не надо путать с PyDoc - это всего-лишь HTML примочка для чтения .doc

Некоторые примеры использования справки

In []:
Комментарии # Документация внутри файла
Функция dir Получение списка атрибутов объектов Строки документирования: __doc__ Документация внутри файла,присоединяемая к объектам

PyDoc: функция help Интерактивная справка по объектам
PyDoc: отчеты в формате HTML Документация к модулям для просмотра в броузере
In [1]:
import sys
>>> dir(sys)
Out[1]:
['__displayhook__',
 '__doc__',
 '__excepthook__',
 '__name__',
 '__package__',
 '__stderr__',
 '__stdin__',
 '__stdout__',
 '_clear_type_cache',
 '_current_frames',
 '_getframe',
 '_mercurial',
 'api_version',
 'argv',
 'builtin_module_names',
 'byteorder',
 'call_tracing',
 'callstats',
 'copyright',
 'displayhook',
 'dllhandle',
 'dont_write_bytecode',
 'exc_clear',
 'exc_info',
 'exc_type',
 'excepthook',
 'exec_prefix',
 'executable',
 'exit',
 'exitfunc',
 'flags',
 'float_info',
 'float_repr_style',
 'getcheckinterval',
 'getdefaultencoding',
 'getfilesystemencoding',
 'getprofile',
 'getrecursionlimit',
 'getrefcount',
 'getsizeof',
 'gettrace',
 'getwindowsversion',
 'hexversion',
 'long_info',
 'maxint',
 'maxsize',
 'maxunicode',
 'meta_path',
 'modules',
 'path',
 'path_hooks',
 'path_importer_cache',
 'platform',
 'prefix',
 'ps1',
 'ps2',
 'ps3',
 'py3kwarning',
 'setcheckinterval',
 'setprofile',
 'setrecursionlimit',
 'settrace',
 'stderr',
 'stdin',
 'stdout',
 'subversion',
 'version',
 'version_info',
 'warnoptions',
 'winver']
In [6]:
list(sys.__dict__.keys())
Out[6]:
['setrecursionlimit',
 'dont_write_bytecode',
 'getfilesystemencoding',
 'long_info',
 'path_importer_cache',
 'stdout',
 'getprofile',
 '__stdin__',
 'meta_path',
 'exc_clear',
 'prefix',
 'getrefcount',
 'byteorder',
 '_clear_type_cache',
 'excepthook',
 'exitfunc',
 'ps1',
 'exc_type',
 'getwindowsversion',
 '__excepthook__',
 'executable',
 'float_info',
 'copyright',
 'gettrace',
 'exec_prefix',
 'version_info',
 'getrecursionlimit',
 'py3kwarning',
 'path_hooks',
 '__package__',
 '_current_frames',
 'platform',
 'maxsize',
 'version',
 'exit',
 'call_tracing',
 'callstats',
 'flags',
 'setcheckinterval',
 '__doc__',
 'api_version',
 'getdefaultencoding',
 'getcheckinterval',
 'maxunicode',
 'settrace',
 'setprofile',
 'argv',
 '__stdout__',
 'winver',
 '__name__',
 'builtin_module_names',
 'subversion',
 '__stderr__',
 'ps3',
 'dllhandle',
 'displayhook',
 'float_repr_style',
 'stdin',
 'modules',
 'warnoptions',
 'getsizeof',
 '_mercurial',
 '__displayhook__',
 '_getframe',
 'stderr',
 'exc_info',
 'path',
 'ps2',
 'maxint',
 'hexversion']
In [12]:
print sys.__package__, sys.__name__, sys._current_frames
None sys <built-in function _current_frames>

In [2]:
print(sys.__doc__)
This module provides access to some objects used or maintained by the
interpreter and to functions that interact strongly with the interpreter.

Dynamic objects:

argv -- command line arguments; argv[0] is the script pathname if known
path -- module search path; path[0] is the script directory, else ''
modules -- dictionary of loaded modules

displayhook -- called to show results in an interactive session
excepthook -- called to handle any uncaught exception other than SystemExit
  To customize printing in an interactive session or to install a custom
  top-level exception handler, assign other functions to replace these.

exitfunc -- if sys.exitfunc exists, this routine is called when Python exits
  Assigning to sys.exitfunc is deprecated; use the atexit module instead.

stdin -- standard input file object; used by raw_input() and input()
stdout -- standard output file object; used by the print statement
stderr -- standard error object; used for error messages
  By assigning other file objects (or objects that behave like files)
  to these, it is possible to redirect all of the interpreter's I/O.

last_type -- type of last uncaught exception
last_value -- value of last uncaught exception
last_traceback -- traceback of last uncaught exception
  These three are only available in an interactive session after a
  traceback has been printed.

exc_type -- type of exception currently being handled
exc_value -- value of exception currently being handled
exc_traceback -- traceback of exception currently being handled
  The function exc_info() should be used instead of these three,
  because it is thread-safe.

Static objects:

float_info -- a dict with information about the float inplementation.
long_info -- a struct sequence with information about the long implementation.
maxint -- the largest supported integer (the smallest is -maxint-1)
maxsize -- the largest supported length of containers.
maxunicode -- the largest supported character
builtin_module_names -- tuple of module names built into this interpreter
version -- the version of this interpreter as a string
version_info -- version information as a named tuple
hexversion -- version information encoded as a single integer
copyright -- copyright notice pertaining to this interpreter
platform -- platform identifier
executable -- absolute path of the executable binary of the Python interpreter
prefix -- prefix used to find the Python library
exec_prefix -- prefix used to find the machine-specific Python library
float_repr_style -- string indicating the style of repr() output for floats
dllhandle -- [Windows only] integer handle of the Python DLL
winver -- [Windows only] version number of the Python DLL
__stdin__ -- the original stdin; don't touch!
__stdout__ -- the original stdout; don't touch!
__stderr__ -- the original stderr; don't touch!
__displayhook__ -- the original displayhook; don't touch!
__excepthook__ -- the original excepthook; don't touch!

Functions:

displayhook() -- print an object to the screen, and save it in __builtin__._
excepthook() -- print an exception and its traceback to sys.stderr
exc_info() -- return thread-safe information about the current exception
exc_clear() -- clear the exception state for the current thread
exit() -- exit the interpreter by raising SystemExit
getdlopenflags() -- returns flags to be used for dlopen() calls
getprofile() -- get the global profiling function
getrefcount() -- return the reference count for an object (plus one :-)
getrecursionlimit() -- return the max recursion depth for the interpreter
getsizeof() -- return the size of an object in bytes
gettrace() -- get the global debug tracing function
setcheckinterval() -- control how often the interpreter checks for events
setdlopenflags() -- set the flags to be used for dlopen() calls
setprofile() -- set the global profiling function
setrecursionlimit() -- set the max recursion depth for the interpreter
settrace() -- set the global debug tracing function


In [3]:
print(sys.getrefcount.__doc__)
getrefcount(object) -> integer

Return the reference count of object.  The count returned is generally
one higher than you might expect, because it includes the (temporary)
reference as an argument to getrefcount().

In [5]:
help(sys.getrefcount)
Help on built-in function getrefcount in module sys:

getrefcount(...)
    getrefcount(object) -> integer
    
    Return the reference count of object.  The count returned is generally
    one higher than you might expect, because it includes the (temporary)
    reference as an argument to getrefcount().


In [4]:
print(int.__doc__)
int(x=0) -> int or long
int(x, base=10) -> int or long

Convert a number or string to an integer, or return 0 if no arguments
are given.  If x is floating point, the conversion truncates towards zero.
If x is outside the integer range, the function returns a long instead.

If x is not a number or if base is given, then x must be a string or
Unicode object representing an integer literal in the given base.  The
literal can be preceded by '+' or '-' and be surrounded by whitespace.
The base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to
interpret the base from the string as an integer literal.
>>> int('0b100', base=0)
4

p. 666 Интерпретатор Python сначала отыскивает список all в модуле, и если он отсутствует, инструкция from * копирует все имена, которые не начинаются с единственного символа подчеркивания.

p. 666 В языке периодически появляются изменения, которые могут повлиять на работоспособность существующего программного кода. Сначала они появляются в виде расширений, которые по умолчанию отключены. Чтобы включить такие расширения, используется инструкция импорта специального вида: from future import имяфункциональнойособенности

p. 670 Список sys.argv в языке Python содержит аргументы командной строки – список строк со словами, введенными в командной строке, где первый элемент списка всегда содержит имя файла сценария

In [13]:
sys.argv
Out[13]:
['-c',
 '-f',
 'C:\\Users\\kiss\\.ipython\\profile_default\\security\\kernel-ee31116f-ef97-4c43-8ca9-463c3348f548.json',
 "--IPKernelApp.parent_appname='ipython-notebook'",
 '--profile-dir',
 'C:\\Users\\kiss\\.ipython\\profile_default',
 '--interrupt=1468',
 '--parent=1676']
In [14]:
sys.path
Out[14]:
['',
 'C:\\Users\\kiss\\Documents\\Python-Django',
 'C:\\Users\\kiss\\Anaconda\\Lib\\site-packages\\django\\bin',
 'C:\\Users\\kiss\\Anaconda\\python27.zip',
 'C:\\Users\\kiss\\Anaconda\\DLLs',
 'C:\\Users\\kiss\\Anaconda\\lib',
 'C:\\Users\\kiss\\Anaconda\\lib\\plat-win',
 'C:\\Users\\kiss\\Anaconda\\lib\\lib-tk',
 'C:\\Users\\kiss\\Anaconda',
 'C:\\Users\\kiss\\Anaconda\\lib\\site-packages',
 'C:\\Users\\kiss\\Anaconda\\lib\\site-packages\\PIL',
 'C:\\Users\\kiss\\Anaconda\\lib\\site-packages\\Sphinx-1.2.3-py2.7.egg',
 'C:\\Users\\kiss\\Anaconda\\lib\\site-packages\\win32',
 'C:\\Users\\kiss\\Anaconda\\lib\\site-packages\\win32\\lib',
 'C:\\Users\\kiss\\Anaconda\\lib\\site-packages\\Pythonwin',
 'C:\\Users\\kiss\\Anaconda\\lib\\site-packages\\runipy-0.1.1-py2.7.egg',
 'C:\\Users\\kiss\\Anaconda\\lib\\site-packages\\setuptools-5.8-py2.7.egg',
 'C:\\Users\\kiss\\Anaconda\\lib\\site-packages\\IPython\\extensions']


Посты чуть ниже также могут вас заинтересовать

20 комментариев:

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

    1. Посмотреть аргументы командой pdb дебаггера args
    шутка... не для зануд

    2-3. Сначала смотрим список атрибутов объекта при помощи команды dir(), потом вызываем справку по каждому атрибуту help()
    Это любимый "прием" М.Лутца.

    4. Словарь объекта , например list(sys.__dict__.keys())

    ОтветитьУдалить
  2. 5- В посте есть несколько команд из библиотеки SYS

    ToDo: Надо бы посмотреть и эту и другие библиотеки... Не забыть это сделать

    ОтветитьУдалить
  3. Чтобы узнать, какие атрибуты содержат объекты встроенных типов, передайте
    функции dir литерал (или существующий объект) требуемого типа. Например,
    чтобы увидеть атрибуты списков и строк, можно передать функции пустой
    объект:
    >>> dir([])
    [‘__add__’, ‘__class__’, ...остальные имена опущены...
    ‘append’, ‘count’, ‘extend’, ‘index’, ‘insert’, ‘pop’, ‘remove’,
    ‘reverse’, ‘sort’]
    >>> dir(‘’)
    [‘__add__’, ‘__class__’, ‘__contains__’, ...остальные имена опущены...
    ‘capitalize’, ‘center’, ‘count’, ‘encode’, ‘endswith’, ‘expandtabs’,
    ‘find’, ‘format’, ‘index’, ‘isalnum’, ‘isalpha’, ‘isdecimal’, ‘isdigit’,
    ‘isidentifier’, ‘islower’, ‘isnumeric’, ‘isprintable’, ‘isspace’, ‘istitle’,
    ‘isupper’, ‘join’, ‘ljust’, ‘lower’, ‘lstrip’, ‘maketrans’, ‘partition’, ‘replace’,
    ‘rfind’, ‘rindex’, ‘rjust’,...остальные имена опущены...]

    ОтветитьУдалить
    Ответы
    1. Того же эффекта можно добиться, передав функции dir имя типа вместо лите-
      рала:
      >>> dir(str) == dir(‘’) # Результат тот же, что и в предыдущем примере
      True
      >>> dir(list) == dir([])
      True

      Удалить
    2. Функция dir служит своего рода «кратким напоминанием» – она предостав-
      ляет список имен атрибутов, но ничего не сообщает о том, что эти имена озна-
      чают. За этой информацией необходимо обращаться к следующему источнику
      документации.

      Удалить
    3. __dict__ или dir(M)

      Доступ к пространствам имен модулей можно получить через атрибут __dict__ или dir(M). Пространства имен модулей, создаваемые операцией
      импортирования, представляют собой словари – доступ к ним можно получить через встроенный атрибут __dict__, ассоциированный с модулем, и с
      помощью функции dir.

      Функция dir – это примерный эквивалент отсортированного списка ключей атрибута __dict__,
      но она включает унаследованные имена классов (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!),
      может возвращать не полный список и
      часто изменяется от версии к версии.

      Удалить
    4. Унаследованные атрибуты класса присоединяются только к объекту класса, и не повторяются в экземплярах.
      Если вам потребуется добавить вывод унаследованных атрибутов, вы можете с помощью ссылки
      __class__
      получить доступ к классу экземпляра и извлечь из его словаря
      __dict__ атрибуты класса, а затем выполнить итерации через содержимое атрибута
      __bases__
      класса, чтобы подняться до уровня суперклассов (настолько высоко, насколько это потребуется).

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

      Удалить
    5. # В Python 2.6:
      >>> bob.__dict__.keys() # Только атрибуты экземпляра
      [‘pay’, ‘job’, ‘name’]
      >>> dir(bob) # + унаследованные атрибуты классов
      [‘__doc__’, ‘__init__’, ‘__module__’, ‘__str__’, ‘giveRaise’, ‘job’, ‘lastName’, ‘name’, ‘pay’]

      # В Python 3.0:
      >>> list(bob.__dict__.keys()) # В 3.0 метод keys возвращает представление,
      [‘pay’, ‘job’, ‘name’] # а не список
      >>> dir(bob) # В 3.0 включаются методы типа класса
      [‘__class__’, ‘__delattr__’, ‘__dict__’, ‘__doc__’, ‘__eq__’, ‘__format__’,
      ‘__ge__’, ‘__getattribute__’, ‘__gt__’, ‘__hash__’, ‘__init__’, ‘__le__’,
      ...часть строк опущена...
      ‘__setattr__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’, ‘__weakref__’,
      ‘giveRaise’, ‘job’, ‘lastName’, ‘name’, ‘pay’]

      Удалить
  4. 6. __doc__
    """ строки в тройных кавычках во всех модулях, классах, методах"""
    Интерпретатор автоматически помещает строки документирования в атрибут
    __doc__ соответствующего объекта.

    ОтветитьУдалить
    Ответы
    1. Самое важное в протоколе документирования заключается в том, что ваши
      комментарии становятся доступны для просмотра в виде атрибутов __doc__
      после того, как файл будет импортирован. Поэтому, чтобы отобразить строки
      документирования, связанные с модулем и его объектами, достаточно просто
      импортировать файл и вывести значения их атрибутов __doc__, где интерпре-
      татор сохраняет текст:
      >>> import docstrings
      16
      function documentation
      can we have your liver then?
      >>> print(docstrings.__doc__)
      Module documentation
      Words Go Here
      >>> print(docstrings.square.__doc__)
      function documentation

      Удалить
  5. Не надо забывать про генератор документации

    PyDoc: отчеты в формате HTML

    ОтветитьУдалить
  6. >>> import builtins
    >>> dir(builtins)
    [‘ArithmeticError’, ‘AssertionError’, ‘AttributeError’, ‘BaseException’,
    ‘BufferError’, ‘BytesWarning’, ‘DeprecationWarning’, ‘EOFError’, ‘Ellipsis’,
    ...множество других имен опущено...
    ‘print’, ‘property’, ‘quit’, ‘range’, ‘repr’, ‘reversed’, ‘round’, ‘set’,
    ‘setattr’, ‘slice’, ‘sorted’, ‘staticmethod’, ‘str’, ‘sum’, ‘super’, ‘tuple’,
    ‘type’, ‘vars’, ‘zip’]
    Имена в этом списке составляют встроенную область видимости языка Python.
    Примерно первая половина списка – это встроенные исключения, а вторая –
    встроенные функции. Согласно правилу LEGB интерпретатор выполняет по-
    иск имен в этом модуле в последнюю очередь. Все имена из этого списка вы
    получаете в свое распоряжение по умолчанию, то есть чтобы их использовать,
    не требуется импортировать какие-либо модули.

    ОтветитьУдалить
    Ответы
    1. Примечание, касающееся различий между версиями: Умолчать об этом нельзя. Модуль builtins, упоминающийся здесь, в версии
      Python 2.6 называется __builtin__.

      Замечу, что в большинстве глобальных областей видимости (включая и интерактивный сеанс) присутствует имя __builtins__ (с символом «s» на конце),
      ссылающееся на модуль builtins (он же __builtin__ в 2.6).

      Если в версии 3.0 импортировать модуль builtins, выражение __builtins__ is builtins вернет True,
      а в версии 2.6 значение True вернет выражение __builtins__ is __builtin__.

      Отсюда следует, что мы можем исследовать встроенную область видимости с помощью вызова функции
      dir(__builtins__)
      в обеих версиях, 3.0 и 2.6, не импортируя модуль.

      Однако в действующих программах для версии 3.0 рекомендуется все-таки использовать модульbuiltins.
      Кто сказал, что описать эту особенность было легко?

      Удалить
  7. Когда мы создаем экземпляр подкласса, он начинает свое существование с пустым словарем пространства имен, но имеет ссылку на класс, стоящий выше
    в дереве наследования. Фактически дерево наследования доступно в виде специальных атрибутов, которые вы можете проверить.
    Экземпляры обладают атрибутом
    __class__,
    который ссылается на класс, а классы имеют атрибут
    __bases__,
    который является кортежем, содержащим ссылки на суперклассы выше в дереве наследования
    (я выполнял этот пример в Python 3.0 – в вер-
    сии 2.6 формат вывода и имена некоторых внутренних атрибутов немного отличаются):

    >>> X = sub()
    >>> X.__dict__ # Словарь пространства имен экземпляра
    {}
    >>> X.__class__ # Класс экземпляра

    >>> sub.__bases__ # Суперклассы данного класса
    (,)
    >>> super.__bases__ # В Python 2.6 возвращает пустой кортеж ()
    (,)

    ОтветитьУдалить
    Ответы
    1. В предыдущем разделе были представлены специальные атрибуты экземпляра и класса
      __class__ и __bases__,
      но не объяснялось, зачем они могут понадобиться. В двух словах, эти атрибуты позволяют осматривать иерархии наследования в вашем программном коде.

      Удалить
  8. Так как атрибуты фактически являются ключами словаря, существует два способа получать и изменять их значения – по квалифицированным именамили индексированием по ключу:

    >>> X.data1, X.__dict__[‘data1’]
    (‘spam’, ‘spam’)
    >>> X.data3 = ‘toast’

    >>> X.__dict__
    {‘data1’: ‘spam’, ‘data3’: ‘toast’, ‘data2’: ‘eggs’}

    >>> X.__dict__[‘data3’] = ‘ham’
    >>> X.data3
    ‘ham’

    ОтветитьУдалить
    Ответы
    1. Однако такая эквивалентность применяется только к атрибутам, фактически присоединенным к экземпляру.
      Так как обращение по квалифицированному имени также вызывает запуск процедуры поиска в дереве наследования, такой способ может обеспечить доступ к атрибутам, которые нельзя получить индексированием словаря.
      Например, унаследованный атрибут

      X.hello
      недоступен через выражение

      X.__dict__[‘hello’]

      (Лутц стр.787)

      Удалить
  9. Кроме того, вы должны знать о возможности возникновения в программах непреднамеренной рекурсии. Как будет показано ниже в этой книге, некоторые
    методы перегрузки операторов в классах, такие как
    __setattr__ и __getattribute__,
    при неправильном использовании могут приводить к рекурсии.
    Рекурсия – это мощный инструмент, но ее лучше использовать только тогда, когда без нее невозможно обойтись!

    ОтветитьУдалить
  10. Благодаря этому все следующие выражения представляют один и тот же атрибут и объект:

    M.name # Полное имя объекта
    M.__dict__[‘name’] # Доступ с использованием словаря пространства имен
    sys.modules[‘M’].name # Доступ через таблицу загруженных модулей
    getattr(M, ‘name’) # Доступ с помощью встроенной функции

    ОтветитьУдалить