python - plugin - pydev eclipse tutorial

Cómo suprimir las advertencias de "variables no utilizadas" en Eclipse/PyDev

Question

Cómo suprimir las advertencias de "variables no utilizadas" en Eclipse / PyDev

Cuando trabajo con funciones que devuelven tuplas, a menudo solo necesito uno de los valores, pero aún así quiero asignar a múltiples variables. Me gustaría poder desactivar temporalmente esta advertencia para poder concentrarme en problemas más serios. Entonces, puedo volver a encenderlo cuando hago más de una verificación final.

Si te estás preguntando por qué haría esto deliberadamente, es solo para facilitar la lectura. Digamos que una función devuelve una tupla de tuplas, varias partes de mi código podrían funcionar con el tercer valor como este:

label, content = myfunc()[2]

A veces, solo me puede interesar la pieza de "contenido", pero encuentro esto ...

tmp, content = myfunc()[2]

... para ser más paralelo (y por lo tanto más legible) que esto:

content = myfunc()[2][1]

Si hay una mejor manera de hacerlo simplemente sin asignarlo a una variable no utilizada desechable, no dude en proporcionar eso como respuesta.

>>> myfunc()[2]
(''lab'', ''val'')
>>> , v = myfunc()[2]
SyntaxError: invalid syntax
>>> tmp, v = myfunc()[2]
>>> 

Answer 1

Agregue el comentario #@UnusedVariable al final de la línea.

Cada advertencia en PyDev tiene un comentario de desactivación similar. Use Solución rápida para descubrirlos (coloque el cursor en la advertencia y presione Ctrl + 1), o consulte estas líneas desde el código fuente de PyDev :

public static final String MSG_TO_IGNORE_TYPE_UNUSED_IMPORT = "@UnusedImport";
public static final String MSG_TO_IGNORE_TYPE_UNUSED_WILD_IMPORT = "@UnusedWildImport";
public static final String MSG_TO_IGNORE_TYPE_UNUSED_VARIABLE = "@UnusedVariable";
public static final String MSG_TO_IGNORE_TYPE_UNDEFINED_VARIABLE = "@UndefinedVariable";
public static final String MSG_TO_IGNORE_TYPE_DUPLICATED_SIGNATURE = "@DuplicatedSignature";
public static final String MSG_TO_IGNORE_TYPE_REIMPORT = "@Reimport";
public static final String MSG_TO_IGNORE_TYPE_UNRESOLVED_IMPORT = "@UnresolvedImport";
public static final String MSG_TO_IGNORE_TYPE_NO_SELF = "@NoSelf";
public static final String MSG_TO_IGNORE_TYPE_UNDEFINED_IMPORT_VARIABLE = "@UndefinedVariable";
public static final String MSG_TO_IGNORE_TYPE_UNUSED_PARAMETER = "@UnusedVariable";
public static final String MSG_TO_IGNORE_TYPE_NO_EFFECT_STMT = "@NoEffect";
public static final String MSG_TO_IGNORE_TYPE_INDENTATION_PROBLEM = "@IndentOk";
public static final String MSG_TO_IGNORE_TYPE_ASSIGNMENT_TO_BUILT_IN_SYMBOL = "@ReservedAssignment";
public static final String MSG_TO_IGNORE_TYPE_PEP8 = "@IgnorePep8";
public static final String MSG_TO_IGNORE_TYPE_ARGUMENTS_MISATCH = "@ArgumentMismatch";

Answer 2

Me encuentro con esto algunas veces cuando uso una característica similar a la que describe cuando se devuelve una tupla. Puede configurar globalmente niveles de advertencia para el análisis de código de PyDev en la sección Preferencias -> PyDev -> Editor -> Análisis de código. En Análisis de código en la pestaña Sin usar, hay una opción para configurar el nivel de advertencia para "Variable sin usar", así como otras ocurrencias.

Answer 3

O bien, puede suprimir una advertencia dada en Eclipse en cualquier idioma (incluido Python) usando un complemento adicional. http://suppresswarnings.drupalgardens.com

También disponible en el mercado:

https://marketplace.eclipse.org/content/marker-manager

Answer 4

Preferencias -> PyDev -> Editor -> Análisis de código, pestaña "Sin uso"

Encuentra el ajuste para

No informe la variable no utilizada si el nombre comienza con: (separados por comas)

y luego use uno de los prefijos en esta lista, o agregue otro prefijo.

Por ejemplo, si tiene una variable desechable "tmp" en el siguiente código:

tmp, content = myfunc()[2]

y tienes ''_'' en tu lista de prefijos para ignorar, luego convierte "tmp" a "_tmp" de esta manera

_tmp, content = myfunc()[2]

Tu error desaparecerá. Creo que esta es una solución más legible que simplemente usar ''_'', como lo sugiere @abarnert, y también evita las complicaciones de entrar en conflicto con la traducción.

Answer 5

Si no necesita el valor de una variable, asígnele la variable especial _ .

En lo que se refiere a Python, en realidad no hay nada especial acerca de _ ; Es solo otro nombre de identificador legal como cualquier otro.

Sin embargo, para la mayoría de las herramientas de estilo "lint" (con suerte incluyendo PyDev) —y, lo que es más importante, los lectores humanos— tiene el significado especial de que "no necesito esta variable, solo estoy poniendo algo aquí porque la API / sintaxis / lo que sea que lo requiera ". Lo que significa que no te advertirán por no usarlo.

Asi que:

_, content = myfunc()[2]

Y sí, tienes razón en que esto suele ser más legible que myfunc()[2][1] . No solo eso, sino que también te ayuda a detectar algunos errores más: si myfunc()[2] no tiene exactamente dos miembros, la asignación de tupla se lanzará, pero el [1] no.

Muy, muy raramente, esto no es una buena idea porque el valor es algo que se debe recolectar de la basura lo antes posible, y vincularlo a _ lugar de no vincularlo en absoluto (por ejemplo, a través de [2][1] ) retrasa eso.

Más en serio, esto entra en conflicto con un idioma diferente que también hace un uso especial de _ : El código que usa gettext para la internacionalización generalmente lo hace:

import gettext
_ = gettext.gettext

O equivalente:

from gettext import gettext as _

Obviamente, no puede utilizar _ como el acceso directo de gettext y el identificador sin significado. (Realmente podría salirse con la suya, porque el significado de gettext está vinculado a nivel de módulo global, y el identificador sin sentido solo debe usarse dentro de los cuerpos de función ... pero aún así, es una muy mala idea intentarlo, porque en algún momento lo hará. termine usando el gettext _ en una función después de que haya asignado un valor local que lo oculte.) Nada le obliga a usar _ en ninguno de los dos casos, pero si usa cualquier otra cosa, es probable que confunda a los lectores (y posiblemente al mismo) herramienta de linting que estás buscando para pacificar en primer lugar). Entonces, tienes que decidir cuál es el más importante para ti en cualquier proyecto dado. (Y generalmente, si estás usando gettext , ese será el más importante).

Si llama repetidamente a myfunc y desecha algunos de los valores, puede considerar escribir una función de envoltorio:

def mywrapperfunc():
    _, content = myfunc()[2]
    return content

Entonces su código puede simplemente hacer:

content = mywrapperfunc()

Esto tiene una serie de ventajas:

• Obviamente, es más fácil de leer que cualquier cosa que requiera que recuerdes que quieres la segunda mitad de una tupla que se encuentra en el índice 2 de la secuencia que devuelve myfunc .
• Te da un lugar para poner un nombre bonito (ojalá mejor que mywrapperfunc ) y / o comentarios / documentación, en caso de que no sea trivial.
• Significa que si luego cambia myfunc el valor que desea ahora está en el índice 3 en lugar de 2, y el segundo miembro de una tupla de 3 elementos en lugar de una tupla de 2 elementos, solo necesita cambiar mywrapperfunc lugar de 20 diferentes. líneas de código.
• También significa que si luego desea usar un idioma _ conflictivo (por ejemplo, para incluir su código con gettext ), solo necesita cambiarlo en un lugar.

Una nota al margen: en el intérprete interactivo, _ tiene un significado especial: está vinculado al resultado del último comando interactivo. Pero eso no significa que no pueda usar _ en el intérprete interactivo. (De hecho, es aún mejor allí, porque todo lo que escondes allí se sobrescribe inmediatamente, por lo que no surge el problema muy raro de GC).