El sistema de ayuda de Python

Al escribir y ejecutar sus programas de Python, es posible que se atasque y necesite ayuda. Es posible que necesite saber el significado de ciertos módulos, clases, funciones, palabras clave, etc. La buena noticia es que Python viene con un sistema de ayuda incorporado. Esto significa que no tienes que buscar ayuda fuera de Python.
En este artículo, aprenderá a usar el sistema de ayuda incorporado de Python.

Función de ayuda Python ()

Esta función nos ayuda a obtener la documentación de una determinada clase, función, variable, módulo, etc. La función se debe usar en la consola de Python para obtener detalles de varios objetos de Python.

Pasando un objeto a la función ayuda ()

La help()función Python tiene la siguiente sintaxis:
>>> help(object)
En la sintaxis anterior, el objectparámetro es el nombre del objeto sobre el que necesita obtener ayuda.
Por ejemplo, para saber más sobre la printfunción de Python , escriba el siguiente comando en la consola de Python:
>>> help(print)
Salida:
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.
Para obtener ayuda para la dictclase, escriba lo siguiente en la consola de Python:
>>> help(dict)
Salida:
Help on class dict in module builtins:

class dict(object)  
 |  dict() -> new empty dictionary
 |  dict(mapping) -> new dictionary initialized from a mapping object's
 |      (key, value) pairs
 |  dict(iterable) -> new dictionary initialized as if via:
 |      d = {}
 |      for k, v in iterable:
 |          d[k] = v
 |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
 |      in the keyword argument list.  For example:  dict(one=1, two=2)
 |  
 |  Methods defined here:
 |  
 |  __contains__(self, key, /)
 |      True if D has a key k, else False.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  

...
También puede pasar un objeto de lista real a la help()función:
>>> help(['a', 'b', 'c'])
Salida:
Help on list object:

class list(object)  
 |  list() -> new empty list
 |  list(iterable) -> new list initialized from iterable's items
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).

...
Podemos ver que cuando se pasa un objeto a la help()función, se imprime la documentación o la página de ayuda. En la siguiente sección, aprenderá a pasar argumentos de cadena a la help()función.

Pasando un argumento de cadena para ayudar ()

Si pasa una cadena como un argumento, la cadena se tratará como el nombre de una función, módulo, palabra clave, método, clase o tema de documentación y se imprimirá la página de ayuda correspondiente. Para marcarlo como un argumento de cadena, enciérrelo entre comillas simples o dobles.
Por ejemplo:
>>> help('print')
Salida:
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.
Aunque pasamos 'imprimir' como un argumento de cadena, todavía obtuvimos la documentación para la printfunción de Python Aquí hay otro ejemplo:
>>> help('def')
Salida:
Function definitions  
********************

A function definition defines a user-defined function object (see  
section *The standard type hierarchy*):

   funcdef        ::= [decorators] "def" funcname "(" [parameter_list] ")" ["->" expression] ":" suite
   decorators     ::= decorator+
   decorator      ::= "@" dotted_name ["(" [parameter_list [","]] ")"] NEWLINE
   dotted_name    ::= identifier ("." identifier)*
   parameter_list ::= (defparameter ",")*
                      | "*" [parameter] ("," defparameter)* ["," "**" parameter]
                      | "**" parameter
                      | defparameter [","] )
   parameter      ::= identifier [":" expression]
   defparameter   ::= parameter ["=" expression]
   funcname       ::= identifier

A function definition is an executable statement.  Its execution binds  
the function name in the current local namespace to a function object  
(a wrapper around the executable code for the function).  This

...
Aquí pasamos "def" como un argumento de cadena a la help()función y devolvimos la documentación para definir funciones.
Si no se encuentra ningún objeto, método, función, clase o módulo coincidentes, se le notificará. Por ejemplo:
>>> help('qwerty')
Salida:
No Python documentation found for 'qwerty'.  
Use help() to get the interactive help utility.  
Use help(str) for help on the str class.  
Se nos notifica que no se ha encontrado documentación para nuestra cadena.
A veces, es posible que tengamos que obtener ayuda sobre una función determinada que se define en una biblioteca de Python determinada. Esto requiere que primero importemos la biblioteca. Un buen ejemplo es cuando necesitamos obtener la documentación para la logfunción definida en la mathbiblioteca de Python En este caso, primero debemos importar la mathbiblioteca y luego llamar a la help()función como se muestra a continuación:
>>> from math import log
>>> help(log)
Salida:
Help on built-in function log in module math:

log(...)  
    log(x[, base])

    Return the logarithm of x to the given base.
    If the base not specified, returns the natural logarithm (base e) of x.

Usando help () sin argumento

La help()función se puede utilizar sin un argumento. Si ejecuta la función sin un argumento, la utilidad de ayuda interactiva de Python se iniciará en la consola del intérprete. Solo tienes que escribir el siguiente comando en la consola de Python:
>>> help()
Esto devolverá la utilidad de ayuda de Python en la que puede escribir el nombre del objeto sobre el que necesita obtener ayuda. Por ejemplo:
help> print  
Salida:
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.
Para volver al aviso anterior, simplemente presione "q".
Aquí hay otro ejemplo:
help> return  
Salida:
The "return" statement  
**********************

   return_stmt ::= "return" [expression_list]

"return" may only occur syntactically nested in a function definition,
not within a nested class definition.

If an expression list is present, it is evaluated, else "None" is  
substituted.

"return" leaves the current function call with the expression list (or
"None") as return value.

When "return" passes control out of a "try" statement with a "finally"  
clause, that "finally" clause is executed before really leaving the  
function.

In a generator function, the "return" statement indicates that the  
generator is done and will cause "StopIteration" to be raised. The  
returned value (if any) is used as an argument to construct  
"StopIteration" and becomes the "StopIteration.value" attribute.

Related help topics: FUNCTIONS  
Para salir de la utilidad de ayuda y volver a la consola de Python, simplemente escriba "quit" y presione la tecla enter:
help> quit  
Salida:
You are now leaving help and returning to the Python interpreter.  
If you want to ask for help on a particular object directly from the  
interpreter, you can type "help(object)".  Executing "help('string')"  
has the same effect as typing a particular string at the help> prompt.  
>>>
En la siguiente sección, analizaremos cómo definir help()nuestros objetos personalizados.

Definición de documentos de ayuda para funciones y clases personalizadas

Es posible que definamos la salida de la help()función para nuestras funciones y clases personalizadas definiendo una cadena de documentos (cadena de documentos). En Python, la primera cadena de comentarios agregada al cuerpo de un método se trata como su cadena de documentación. El comentario tiene que estar rodeado de tres comillas dobles. Por ejemplo:
def product(a, b):  
    """
    This function multiplies two given integers, a and b
    :param x: integer
    :param y: integer
    :returns: integer
    """
    return a * b
En el ejemplo anterior, hemos definido una función llamada productEsta función multiplica dos valores enteros ay se le bpasa como argumentos / parámetros. Vea el comentario incluido dentro de tres comillas dobles:
    """
    This function multiplies two given integers, a and b
    :param x: integer
    :param y: integer
    :returns: integer
    """
Esto será tratado como la cadena de documentos para la función product.
Ahora, crea un nuevo archivo y dale el nombre "myfile.py". Agregue el siguiente código al archivo:
def product(a, b):  
    """
    This function multiplies two given integers, a and b
    :param x: integer
    :param y: integer
    :returns: integer
    """
    return a * b

class Student:  
    """
    Student class in Python. It will store student details
    """
    admission = 0
    name = ''

    def __init__(self, adm, n):
        """
        A constructor of the student object
        :param adm: a positive integer,
        :param n: a string
        """
        self.admission = adm
        self.name = n
En el ejemplo anterior, se ha definido una cadena de documentación para una función, clase y métodos.
Ahora debemos demostrar cómo podemos obtener la cadena de documentación anterior como la documentación de ayuda en nuestra consola Python.
Primero, debemos ejecutar el script en la consola para cargar tanto la función como la definición de clase en el entorno de Python. Podemos usar el exec()método de Python para esto. Ejecute el siguiente comando en la consola de Python:
>>> exec(open("myfile.py").read())
Alternativamente, si ha escrito el código dentro del IDLE de Python, simplemente debe ejecutarlo.
Ahora podemos confirmar si la función y los módulos de clase han sido detectados ejecutando el globals()comando en la consola de Python:
>>> globals()
En mi caso, obtengo el siguiente resultado:
{'__doc__': None, 'log': <built-in function log>, '__builtins__': <module 'builtins' (built-in)>, '__spec__': None, '__package__': None, '__name__': '__main__', '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__file__': 'C:/Users/admin/myfile.py', 'Student': <class '__main__.Student', 'product': <function product at 0x0000000003569B70>}
Como se muestra en la salida anterior, ambos Studentproductestán en el diccionario de alcance global. Ahora podemos usar la help()función para obtener la ayuda para la Studentclase y la productfunción. Simplemente ejecute el siguiente comando en la consola de Python:
>>> help('myfile')
Salida:
Help on module myfile:

NAME  
    myfile

CLASSES  
    builtins.object
        Student

    class Student(builtins.object)
     |  Student class in Python. It will store student details
     |  
     |  Methods defined here:
     |  
     |  __init__(self, adm, n)
     |      A constructor of the student object
     |      :param adm: a positive integer,
     |      :param n: a string
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  admission = 0
     |  
     |  name = ''

FUNCTIONS  
    product(a, b)
        This function multiplies two given integers, a and b
        :param x: integer
        :param y: integer
        :returns: integer

FILE  
    c:\users\admin\myfile.py
Revisemos la documentación de ayuda para la productfunción:
>>> help('myfile.product')
Salida:
Help on function product in myfile:

myfile.product = product(a, b)  
    This function multiplies two given integers, a and b
    :param x: integer
    :param y: integer
    :returns: integer
Ahora, permítanos acceder a la documentación de ayuda para la Studentclase:
>>> help('myfile.Student')
Salida:
Help on class Student in myfile:

myfile.Student = class Student(builtins.object)  
 |  Student class in Python. It will store student details
 |  
 |  Methods defined here:
 |  
 |  __init__(self, adm, n)
 |      A constructor of the student object
 |      :param adm: a positive integer,
 |      :param n: a string
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  admission = 0
 |  
 |  name = ''
En la salida, podemos ver la documentación que escribimos para la Studentclase.

Conclusión

Python viene con un sistema integrado desde el cual podemos obtener ayuda con respecto a módulos, clases, funciones y palabras clave. Se puede acceder a esta utilidad de ayuda mediante el uso de la help()función de Python en el REPL. Cuando llamamos a esta función y le pasamos un objeto, devuelve la página de ayuda o la documentación del objeto. Cuando ejecutamos la función sin un argumento, la utilidad de ayuda se abre donde podemos obtener ayuda sobre los objetos de forma interactiva. Finalmente, para obtener ayuda con respecto a nuestras clases y funciones personalizadas, podemos definir cadenas de documentación.

Acerca de: Programator

Somos Instinto Programador

0 comentarios:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

Con tecnología de Blogger.