PyLint, PyChecker o PyFlakes? [cerrado]

Question

Me gustaría recibir comentarios sobre estas herramientas en:

• características;
• adaptabilidad;
• facilidad de uso y curva de aprendizaje.

Answer 1

Bueno, tengo un poco de curiosidad, así que solo probé el 3 justo después de hacer la pregunta ;-)

Ok, esta no es una revisión muy seria, pero esto es lo que puedo decir:

Probé las herramientas con la configuración predeterminada (es importante porque puedes elegir tus reglas de verificación) en el siguiente script:

#!/usr/local/bin/python
# by Daniel Rosengren modified by e-satis

import sys, time
stdout = sys.stdout

BAILOUT = 16
MAX_ITERATIONS = 1000

class Iterator(object) :

    def __init__(self):

        print 'Rendering...'
        for y in xrange(-39, 39): 
            stdout.write('\n')
            for x in xrange(-39, 39):
                if self.mandelbrot(x/40.0, y/40.0) :
                    stdout.write(' ')
                else:
                    stdout.write('*')


    def mandelbrot(self, x, y):
        cr = y - 0.5
        ci = x
        zi = 0.0
        zr = 0.0

        for i in xrange(MAX_ITERATIONS) :
            temp = zr * zi
            zr2 = zr * zr
            zi2 = zi * zi
            zr = zr2 - zi2 + cr
            zi = temp + temp + ci

            if zi2 + zr2 > BAILOUT:
                return i

        return 0

t = time.time()
Iterator() 
print '\nPython Elapsed %.02f' % (time.time() - t)

Como resultado:

• PyChecker es problemático porque compila el módulo para analizarlo. Si no desea que se ejecute su código (por ejemplo, realiza una consulta SQL), está mal.
Se supone que
• PyFlakes es lite. De hecho, decidió que el código era perfecto. Estoy buscando algo bastante severo, así que no creo que vaya por él.
• PyLint ha sido muy hablador y calificó el código 3/10 (¡Dios mío, soy un codificador sucio!).

Puntos fuertes de PyLint:

• Informe muy descriptivo y preciso.
• Detecta algunos olores de código. Aquí me dijo que dejara mi clase para escribir algo con funciones porque el enfoque OO era inútil en este caso específico. Algo que sabía, pero nunca esperé que una computadora me dijera :-p
• El código totalmente corregido se ejecuta más rápido (sin clase, sin enlace de referencia ...).
• Hecho por un equipo francés. Ok, no es una ventaja para todos, pero me gusta ;-)

Contras de PyLint:

• Algunas reglas son realmente estrictas. Sé que puede cambiarlo y que el valor predeterminado es hacer coincidir PEP8, pero ¿es un delito escribir 'for x in seq'? Aparentemente sí porque no puedes escribir un nombre de variable con menos de 3 letras. Voy a cambiar eso.
• Muy, muy hablador. Prepárate para usar tus ojos.

Script corregido (con cadenas de documentos perezosos y nombres de variables):

#!/usr/local/bin/python
# by Daniel Rosengren, modified by e-satis
"""
Module doctring
"""


import time
from sys import stdout

BAILOUT = 16
MAX_ITERATIONS = 1000

def mandelbrot(dim_1, dim_2):
    """
    function doc string
    """
    cr1 = dim_1 - 0.5
    ci1 = dim_2
    zi1 = 0.0
    zr1 = 0.0

    for i in xrange(MAX_ITERATIONS) :
        temp = zr1 * zi1
        zr2 = zr1 * zr1
        zi2 = zi1 * zi1
        zr1 = zr2 - zi2 + cr1
        zi1 = temp + temp + ci1

        if zi2 + zr2 > BAILOUT:
            return i

    return 0

def execute() :
    """
    func doc string
    """
    print 'Rendering...'
    for dim_1 in xrange(-39, 39): 
        stdout.write('\n')
        for dim_2 in xrange(-39, 39):
            if mandelbrot(dim_1/40.0, dim_2/40.0) :
                stdout.write(' ')
            else:
                stdout.write('*')


START_TIME = time.time()
execute()
print '\nPython Elapsed %.02f' % (time.time() - START_TIME)

EDITAR:

Gracias a Rudiger Wolf, descubrí pep8 que hace exactamente lo que su nombre sugiere: hacer coincidir PEP8. Ha encontrado varios sintaxis de sintaxis que PyLint no encontró. Pero PyLint encontró cosas que no estaban específicamente vinculadas a PEP8 pero que eran interesantes. Ambas herramientas son interesantes y complementarias.

Eventualmente usaré ambos, ya que son realmente fáciles de instalar (a través de paquetes o herramientas de configuración) y el texto de salida es muy fácil de encadenar.

Para darle una pequeña idea de su salida:

pep8 :

./python_mandelbrot.py:4:11: E401 multiple imports on one line
./python_mandelbrot.py:10:1: E302 expected 2 blank lines, found 1
./python_mandelbrot.py:10:23: E203 whitespace before ':'
./python_mandelbrot.py:15:80: E501 line too long (108 characters)
./python_mandelbrot.py:23:1: W291 trailing whitespace
./python_mandelbrot.py:41:5: E301 expected 1 blank line, found 3

PyLint :

************* Module python_mandelbrot
C: 15: Line too long (108/80)
C: 61: Line too long (85/80)
C:  1: Missing docstring
C:  5: Invalid name "stdout" (should match (([A-Z_][A-Z0-9_]*)|(__.*__))$)
C: 10:Iterator: Missing docstring
C: 15:Iterator.__init__: Invalid name "y" (should match [a-z_][a-z0-9_]{2,30}$)
C: 17:Iterator.__init__: Invalid name "x" (should match [a-z_][a-z0-9_]{2,30}$)

[...] and a very long report with useful stats like :

Duplication
-----------

+-------------------------+------+---------+-----------+
|                         |now   |previous |difference |
+=========================+======+=========+===========+
|nb duplicated lines      |0     |0        |=          |
+-------------------------+------+---------+-----------+
|percent duplicated lines |0.000 |0.000    |=          |
+-------------------------+------+---------+-----------+

Answer 2

pep8 se agregó recientemente a PyPi.

• pep8 - Comprobador de guía de estilo de Python
• pep8 es una herramienta para verificar su código de Python contra algunas de las convenciones de estilo en PEP 8.

Ahora es muy fácil verificar su código con pep8.

Ver http://pypi.python.org/pypi/pep8