4.《python自省指南》学习

>>> help
Type help() for interactive help, or help(object) for help about object.
>>> help()

Welcome to Python 3.6's help utility!

If this is your first time using Python, you should definitely check out
the tutorial on the Internet at https://docs.python.org/3.6/tutorial/.

Enter the name of any module, keyword, or topic to get help on writing
Python programs and using Python modules.  To quit this help utility and
return to the interpreter, just type "quit".
...
help> keywords

Here is a list of the Python keywords.  Enter any keyword to get more help.

False               def                 if                  raise
None                del                 import              return
True                elif                in                  try
and                 else                is                  while
as                  except              lambda              with
assert              finally             nonlocal            yield
break               for                 not                 
class               from                or                  
continue            global              pass                

help> modules

Please wait a moment while I gather a list of all available modules...

PIL                 base64              idlelib             runpy
__future__          bdb                 idna                runscript
__main__            binascii            idna_ssl            sched
_ast                binhex              imaplib             scrolledlist
_asyncio            bisect              imghdr              search
_bisect             browser             imp                 
...
Enter any module name to get more help.  Or, type "modules spam" to search
for modules whose name or summary contain the string "spam".
>>> help('print')
Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream. 

>>> import sys
>>> sys.executable            #sys.executable 变量，它包含到 Python 解释器的路径；    
'D:\\Python36\\pythonw.exe' 
>>> sys.platform                #platform变量显示解释器所处的操作系统；
'win32'
>>> sys.version                 # ersion变量说明解释器的版本；
'3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 16:07:46) [MSC v.1900 32 bit (Intel)]'
>>> sys.argv[0]                 #vargv变量是一个包含命令行参数的列表；
''                              #argv[0]是脚本运行的路径，当我们以交互方式运行 Python 时，这个值是空字符串；
>>> sys.path                    #path 变量是模块搜索路径，Python 在导入期间将在其中的目录列表中寻找模块。最前面的空字符串 '' 是指当前目录；
['', 'D:\\Python36\\Lib\\idlelib', 'D:\\Python36\\python36.zip', 'D:\\Python36\\DLLs', 'D:\\Python36\\lib', 'D:\\Python36', 'D:\\Python36\\lib\\site-packages']
#变量sys.stdin、sys.stdout和sys.stderr是类似于文件的流对象，表示标准的UNIX概念：标准输入、标准输出和标准错误。
>>> sys.stdin                    #Python从sys.stdin获取输入(如，用于input中),
<idlelib.run.PseudoInputFile object at 0x02343F50>
>>> sys.stdout                     # 将输出打印到sys.stdout。
<idlelib.run.PseudoOutputFile object at 0x02343F70>
>>> sys.stderr
<idlelib.run.PseudoOutputFile object at 0x02343F90>
>>> 

'''一个标准数据输入源是sys.stdin。当程序从标准输入读取时，你可通过输入来提供文本，也可使用管道将标准输入关联到其他程序的标准输出。你提供给print的文本出现在sys.stdout中，向input提供的提示信息也出现在这里。写入到sys.stdout的数据通常出现在屏幕上，但可使用管道将其重定向到另一个程序的标准输入。错误消息（如栈跟踪）被写入到sys.stderr，但与写入到sys.stdout的内容一样，可对其进行重定向，例如：$ cat somefile.txt | python somescript.py | sort。可以认为，somescript.py从其sys.stdin中读取数据（这些数据是somefile.txt写入的），并将结果写入到其sys.stdout（sort将从这里获取数据）。'''
#somescript.py内容
import sys
text = sys.stdin.read()
words = text.split()
wordcount = len(words)
print('Wordcount:', wordcount)
#somefile.txt内容
Your mother was a hamster and your
father smelled of elderberries.

cat somefile.txt | python somescript.py的结果如下：
Wordcount: 11

>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__']
>>>
>>> dir(sys)
['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames', '_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 'copyright',
...
#在 dir() 示例中，有一个属性是 __doc__ 属性。这个属性是一个字符串，它包含了描述对象的注释，python称之为文档字符串或 docstring。文档字符串通常包含嵌入的换行 \n ，如何要使其变得易读，可以print出来
>>> sys.__doc__
"This module provides access to some objects used or maintained by the\ninterpreter and to functions that interact strongly with the interpreter.\n\nDynamic objects:\n\nargv -- command line arguments; argv[0] is the script pathname if known\npath -- module search path; path[0] is the script directory, else 
...
>>> 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 knownpath -- module search path; path[0] is the script directory, else
...

>>> help(type)
Help on class type in module builtins:

class type(object)
 |  type(object_or_name, bases, dict)
 |  type(object) -> the object's type
 |  type(name, bases, dict) -> a new type
 |  
 |  Methods defined here:
 |  
 |  __call__(self, /, *args, **kwargs)
 |      Call self as a function.
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __dir__(...)
 |      __dir__() -> list
 |      specialized __dir__ implementation for types
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
...
>>> 
>>> type.__doc__
"type(object_or_name, bases, dict)\ntype(object) -> the object's type\ntype(name, bases, dict) -> a new type"
>>> dir(type)
['__abstractmethods__', '__base__', '__bases__', '__basicsize__', '__call__', '__class__', '__delattr__', '__dict__', '__dictoffset__', '__dir__', '__doc__', '__eq__', '__flags__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__instancecheck__', '__itemsize__', '__le__', '__lt__', '__module__', '__mro__', '__name__', '__ne__', '__new__', '__prepare__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasscheck__', '__subclasses__', '__subclasshook__', '__text_signature__', '__weakrefoffset__', 'mro']
>>> object
<class 'object'>
>>> object.__doc__
'The most base type'
>>> help(object)
Help on class object in module builtins:

class object
 |  The most base type
>>> 
>>> 
>>> help('class')
Class definitions
*****************

A class definition defines a class object (see section The standard
type hierarchy):

   classdef    ::= [decorators] "class" classname [inheritance] ":" suite
   inheritance ::= "(" [argument_list] ")"
   classname   ::= identifier

A class definition is an executable statement.  The inheritance list
usually gives a list of base classes (see Metaclasses for more
advanced uses), so each item in the list should evaluate to a class
object which allows subclassing.  Classes without an inheritance list
inherit, by default, from the base class "object"; hence,

   class Foo:
       pass

is equivalent to

   class Foo(object):
       pass

>>> print.__name__
'print'
>>> import __main__
>>> help(__main__)
Help on module __main__:

NAME
    __main__

DATA
    __annotations__ = {}

FILE
    (built-in)
>>> __main__
<module '__main__' (built-in)>
>>> class A:
    pass

>>> A.__name__
'A'
>>> __name__
'__main__'
>>> A.__main__
Traceback (most recent call last):
  File "<pyshell#19>", line 1, in <module>
    A.__main__
AttributeError: type object 'A' has no attribute '__main__'
>>> __main__
<module '__main__' (built-in)>
>>> help(__main__)
Help on module __main__:

NAME
    __main__

CLASSES
    builtins.object
        A
    
    class A(builtins.object)
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)

DATA
    __annotations__ = {}

FILE
    (built-in)


>>> class B:
    pass

>>> help(__main__)
Help on module __main__:

NAME
    __main__

CLASSES
    builtins.object
        A
        B
    
    class A(builtins.object)
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
    
    class B(builtins.object)
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)

DATA
    __annotations__ = {}

FILE
    (built-in)
>>> dir(__main__)
['A', 'B', '__annotations__', '__builtins__', '__doc__', '__loader__', '__main__', '__name__', '__package__', '__spec__', 'sys']
>>> import json
>>> dir(__main__)
['A', 'B', '__annotations__', '__builtins__', '__doc__', '__loader__', '__main__', '__name__', '__package__', '__spec__', 'json', 'sys']

>>> class A:
    pass

>>> type(A)
<class 'type'>
>>> a=A()
>>> type(a)
<class '__main__.A'> 

>>> help(id)
Help on built-in function id in module builtins:

id(obj, /)
    Return the identity of an object.
    
    This is guaranteed to be unique among simultaneously existing objects.
    (CPython uses the object's memory address.)

>>> id.__doc__
     
"Return the identity of an object.\n\nThis is guaranteed to be unique among simultaneously existing objects.\n(CPython uses the object's memory address.)"
>>> type(id)
     
<class 'builtin_function_or_method'>
>>> a=5
     
>>> b=a
     
>>> id(a)
     
1664672592
>>> id(b)
     
1664672592
>>> 

>>> help(callable)
     
Help on built-in function callable in module builtins:

callable(obj, /)
    Return whether the object is callable (i.e., some kind of function).
    
    Note that classes are callable, as are instances of classes with a
    __call__() method.

>>> callable.__doc__
     
'Return whether the object is callable (i.e., some kind of function).\n\nNote that classes are callable, as are instances of classes with a\n__call__() method.'
>>> type(callable)
     
<class 'builtin_function_or_method'>
>>> callable(print)
     
True
>>> callable('a')
     
False
>>> help(isinstance)
     
Help on built-in function isinstance in module builtins:

isinstance(obj, class_or_tuple, /)
    Return whether an object is an instance of a class or of a subclass thereof.
    
    A tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to
    check against. This is equivalent to ``isinstance(x, A) or isinstance(x, B)
    or ...`` etc.

>>> isinstance.__doc__
     
'Return whether an object is an instance of a class or of a subclass thereof.\n\nA tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to\ncheck against. This is equivalent to ``isinstance(x, A) or isinstance(x, B)\nor ...`` etc.'
>>> type(callable)
     
<class 'builtin_function_or_method'>
>>> callable(43, int)
     
Traceback (most recent call last):
  File "<pyshell#35>", line 1, in <module>
    callable(43, int)
TypeError: callable() takes exactly one argument (2 given)
>>> type(isinstance)
     
<class 'builtin_function_or_method'>
>>> isinstance(45, int)
     
True
>>> isinstance('a', int)
     
False
>>> isinstance('a', str)
     
True
>>> help(issubclass)
     
Help on built-in function issubclass in module builtins:

issubclass(cls, class_or_tuple, /)
    Return whether 'cls' is a derived from another class or is the same class.
    
    A tuple, as in ``issubclass(x, (A, B, ...))``, may be given as the target to
    check against. This is equivalent to ``issubclass(x, A) or issubclass(x, B)
    or ...`` etc.

>>> issubclass.__doc__
     
"Return whether 'cls' is a derived from another class or is the same class.\n\nA tuple, as in ``issubclass(x, (A, B, ...))``, may be given as the target to\ncheck against. This is equivalent to ``issubclass(x, A) or issubclass(x, B)\nor ...`` etc."
>>> type(issubclass)
     
<class 'builtin_function_or_method'>
>>> class A:
     pass

     
>>> class B(A):
     pass

     
>>> issubclass(B, A)
     
True
>>> class C:
     pass

     
>>> issubclass(B, C)
     
False
>>>