Go to main content

man pages section 1: User Commands

Exit Print View

Updated: Wednesday, February 9, 2022

pylint (1)


pylint - python code static checker


pylint [ OPTIONS ] [ <arguments> ]


pylint(1)                   General Commands Manual                  pylint(1)

       pylint - python code static checker

       pylint [ OPTIONS ] [ <arguments> ]

       pylint  is  a  Python  source code analyzer which looks for programming
       errors, helps enforcing a coding standard  and  sniffs  for  some  code
       smells (as defined in Martin Fowler's Refactoring book)

       Pylint  can be seen as another PyChecker since nearly all tests you can
       do with PyChecker can also be done with Pylint. However, Pylint  offers
       some  more features, like checking length of lines of code, checking if
       variable names are well-formed according to your  coding  standard,  or
       checking if declared interfaces are truly implemented, and much more.

       Additionally, it is possible to write plugins to add your own checks.

       Pylint  is  shipped with "pyreverse" (UML diagram generator) and "symi-
       lar" (an independent similarities checker).

              show program's version number and exit

       --help, -h
              show this help message and exit

              more verbose help.

              Python code to execute, usually for sys.path  manipulation  such
              as pygtk.require().

       --errors-only, -E
              In  error mode, checkers without error messages are disabled and
              for others, only  the  ERROR  messages  are  displayed,  and  no
              reports are done by default.

       --py3k In Python 3 porting mode, all checkers will be disabled and only
              messages emitted by the porting checker will be displayed.

       --verbose, -v
              In verbose mode, extra non-checker-related  info  will  be  dis-

              Add  files  or directories to the blacklist. They should be base
              names, not paths. [default: CVS]

              Add files or directories matching  the  regex  patterns  to  the
              blacklist.  The  regex  matches  against  base names, not paths.
              [default: none]

              Pickle collected data for later comparisons. [default: yes]

              List of plugins (as comma  separated  values  of  python  module
              names)   to  load,  usually  to  register  additional  checkers.
              [default: none]

              Specify a score threshold to be exceeded  before  program  exits
              with error. [default: 10]

       --jobs=<n-processes>, -j <n-processes>
              Use  multiple  processes  to  speed up Pylint. Specifying 0 will
              auto-detect the number of processors available to use. [default:

              Control the amount of potential inferred values when inferring a
              single object. This can help the performance when  dealing  with
              large functions or complex, nested conditions.  [default: 100]

              A  comma-separated  list of package or module names from where C
              extensions may be loaded. Extensions are loading into the active
              Python interpreter and may run arbitrary code. [default: none]

              When enabled, pylint would attempt to guess common misconfigura-
              tion and emit  user-friendly  hints  instead  of  false-positive
              error messages. [default: yes]

              Always  return  a 0 (non-error) status code, even if lint errors
              are found. This is primarily useful  in  continuous  integration

              Interpret  the stdin as a python script, whose filename needs to
              be passed as the module_or_package argument.

              Specify a configuration file to load.

              Display a help message for the given message id  and  exit.  The
              value may be a comma separated list of message ids.

              Generate pylint's messages.

              Display  a  list  of what messages are enabled and disabled with
              the given configuration.

              List pylint's message groups.

              Generate pylint's confidence levels.

              Generate pylint's full documentation.

              Generate a sample configuration file according  to  the  current
              configuration.  You can put other options before this one to get
              them in the generated configuration.

              Only show warnings with  the  listed  confidence  levels.  Leave
              empty  to  show  all.  Valid  levels:  HIGH,  INFERENCE,  INFER-
              ENCE_FAILURE, UNDEFINED. [default: none]

       --enable=<msg ids>, -e <msg ids>
              Enable the message, report, category or checker with  the  given
              id(s).  You  can  either  give  multiple identifier separated by
              comma (,) or put this option multiple time (only on the  command
              line,  not in the configuration file where it should appear only
              once). See also the "--disable" option for examples.

       --disable=<msg ids>, -d <msg ids>
              Disable the message, report, category or checker with the  given
              id(s).  You  can  either  give multiple identifiers separated by
              comma (,) or put this option multiple times (only on the command
              line,  not in the configuration file where it should appear only
              once). You can also use "--disable=all"  to  disable  everything
              first  and  then  reenable  specific checks. For example, if you
              want to run only the similarities checker, you can  use  "--dis-
              able=all  --enable=similarities".  If  you  want to run only the
              classes checker, but have no Warning level  messages  displayed,
              use "--disable=all --enable=classes --disable=W".

       --output-format=<format>, -f <format>
              Set  the  output  format. Available formats are text, parseable,
              colorized, json and msvs (visual studio). You can  also  give  a
              reporter    class,    e.g.   mypackage.mymodule.MyReporterClass.
              [default: text]

       --reports=<y_or_n>, -r <y_or_n>
              Tells whether to display a full report  or  only  the  messages.
              [default: no]

              Python expression which should return a score less than or equal
              to 10. You have access  to  the  variables  'error',  'warning',
              'refactor',  and  'convention'  which contain the number of mes-
              sages in each category, as well  as  'statement'  which  is  the
              total  number  of statements analyzed. This score is used by the
              global evaluation report (RP0004). [default: 10.0 - ((float(5  *
              error + warning + refactor + convention) / statement) * 10)]

       --score=<y_or_n>, -s <y_or_n>
              Activate the evaluation score. [default: yes]

              Template  used  to  display messages. This is a python new-style
              format string used to format the message  information.  See  doc
              for all details.

       --logging-modules=<comma separated list>
              Logging modules to check that the string format arguments are in
              logging function parameter format. [default: logging]

       --logging-format-style=<old (%) or new ({) or fstr (f'')>
              Format style used to check logging format  string.  `old`  means
              using  %  formatting, `new` is for `{}` formatting,and `fstr` is
              for f-strings. [default: old]

       --spelling-dict=<dict name>
              Spelling dictionary name. Available dictionaries: none. To  make
              it work, install the python-enchant package. [default: none]

       --spelling-ignore-words=<comma separated words>
              List  of  comma  separated  words  that  should  not be checked.
              [default: none]

       --spelling-private-dict-file=<path to file>
              A path to a file that contains the private dictionary; one  word
              per line. [default: none]

              Tells  whether  to store unknown words to the private dictionary
              (see the --spelling-private-dict-file option) instead of raising
              a message. [default: no]

              Limits  count  of  emitted  suggestions  for  spelling mistakes.
              [default: 4]

       --notes=<comma separated values>
              List of note tags to  take  in  consideration,  separated  by  a
              comma. [default: FIXME,XXX,TODO]

              Regular expression of note tags to take in consideration.

              This  flag  controls  whether pylint should warn about no-member
              and similar checks whenever an opaque object  is  returned  when
              inferring.  The  inference can return multiple potential results
              while evaluating a Python object, but some branches might not be
              evaluated,  which results in partial inference. In that case, it
              might be useful to still emit no-member and other checks for the
              rest of the inferred objects. [default: yes]

              Tells  whether missing members accessed in mixin class should be
              ignored. A mixin class is detected if its name ends with "mixin"
              (case insensitive). [default: yes]

              Tells  whether  to  warn about missing members when the owner of
              the attribute is inferred to be None. [default: yes]

       --ignored-modules=<module names>
              List of module names for which member attributes should  not  be
              checked (useful for modules/projects where namespaces are manip-
              ulated during runtime and thus existing member attributes cannot
              be  deduced  by  static  analysis). It supports qualified module
              names, as well as Unix pattern matching. [default: none]

       --ignored-classes=<members names>
              List of class names for which member attributes  should  not  be
              checked  (useful  for  classes with dynamically set attributes).
              This  supports  the  use  of  qualified  names.  [default:  opt-

       --generated-members=<members names>
              List  of  members which are set dynamically and missed by pylint
              inference system, and so shouldn't trigger E1101 when  accessed.
              Python regular expressions are accepted. [default: none]

       --contextmanager-decorators=<decorator names>
              List  of  decorators that produce context managers, such as con-
              textlib.contextmanager. Add to this list to register other deco-
              rators  that  produce  valid  context  managers.  [default: con-

       --missing-member-hint-distance=<member hint edit distance>
              The minimum edit distance a name should have in order to be con-
              sidered a similar match for a missing member name. [default: 1]

       --missing-member-max-choices=<member hint max choices>
              The  total  number of similar names that should be taken in con-
              sideration when showing a hint for a missing  member.  [default:

       --missing-member-hint=<missing member hint>
              Show  a  hint  with  possible  names  when a member name was not
              found. The aspect of finding the hint is based on edit distance.
              [default: yes]

       --signature-mutators=<decorator names>
              List  of  decorators  that  change  the signature of a decorated
              function. [default: none]

              Tells whether we should check  for  unused  import  in  __init__
              files. [default: no]

              A  regular expression matching the name of dummy variables (i.e.
              expected to not be  used).  [default:  _+$|(_[a-zA-Z0-9_]*[a-zA-

       --additional-builtins=<comma separated list>
              List  of  additional  names  supposed to be defined in builtins.
              Remember that you should avoid defining new builtins when possi-
              ble. [default: none]

              List  of strings which can identify a callback function by name.
              A callback name must start or end with  one  of  those  strings.
              [default: cb_,_cb]

       --redefining-builtins-modules=<comma separated list>
              List  of  qualified module names which can have objects that can
              redefine                   builtins.                   [default:

              Argument  names  that  match  this  expression  will be ignored.
              Default   to   name   with   leading    underscore.    [default:

              Tells  whether  unused  global  variables should be treated as a
              violation. [default: yes]

              Maximum number of nested  blocks  for  function  /  method  body
              [default: 5]

              Complete name of functions that never returns. When checking for
              inconsistent-return-statements if a never returning function  is
              called  then  it will be considered as an explicit return state-
              ment and no message will be printed. [default: sys.exit]

              Maximum number of characters on a single line. [default: 100]

              Regexp for a line that is allowed to be longer than  the  limit.
              [default: ^\s*(# )?<?https?://\S+>?$]

              Allow  the  body  of an if to be on the same line as the test if
              there is no else. [default: no]

              Allow the body of a class to be on the same line as the declara-
              tion if body contains single statement. [default: no]

              List  of  optional  constructs  for which whitespace checking is
              disabled. `dict-separator` is used to allow tabulation in dicts,
              etc.: {1  : 1,\n222: 2}. `trailing-comma` allows a space between
              comma and closing bracket: (a, ). `empty-line` allows space-only
              lines. [default: trailing-comma,dict-separator]

              Maximum number of lines in a module. [default: 1000]

              String  used as indentation unit. This is usually "    " (4 spa-
              ces) or "\t" (1 tab). [default: '    ']

              Number of spaces of indent required inside a hanging or  contin-
              ued line. [default: 4]

       --expected-line-ending-format=<empty or LF or CRLF>
              Expected format of line ending, e.g. empty (any line ending), LF
              or CRLF. [default: none]

              Deprecated modules which should not  be  used,  separated  by  a
              comma. [default: optparse,tkinter.tix]

              Couples  of modules and preferred modules, separated by a comma.
              [default: none]

              Create a graph of every (i.e. internal and  external)  dependen-
              cies  in  the  given  file (report RP0402 must not be disabled).
              [default: none]

              Create a graph  of  external  dependencies  in  the  given  file
              (report RP0402 must not be disabled). [default: none]

              Create  a  graph  of  internal  dependencies  in  the given file
              (report RP0402 must not be disabled). [default: none]

              Force import order to recognize a module as part of the standard
              compatibility libraries.

              Force  import  order  to  recognize  a module as part of a third
              party library. [default: enchant]

              List of modules that can be imported at any level, not just  the
              top level one. [default: none]

              Analyse import fallback blocks. This can be used to support both
              Python 2 and 3 compatible code, which means that the block might
              have  code that exists only in one or another interpreter, lead-
              ing to false positives when analysed. [default: no]

              Allow  wildcard  imports  from  modules  that  define   __all__.
              [default: no]

       --overgeneral-exceptions=<comma-separated class names>
              Exceptions  that will emit a warning when being caught. Defaults
              to "BaseException,  Exception".  [default:  BaseException,Excep-

       --defining-attr-methods=<method names>
              List  of  method  names  used  to declare (i.e. assign) instance
              attributes. [default: __init__,__new__,setUp,__post_init__]

       --valid-classmethod-first-arg=<argument names>
              List of valid names for the first argument in  a  class  method.
              [default: cls]

       --valid-metaclass-classmethod-first-arg=<argument names>
              List  of valid names for the first argument in a metaclass class
              method. [default: cls]

       --exclude-protected=<protected access exclusions>
              List of member names, which should be  excluded  from  the  pro-
              tected            access            warning.           [default:

              Minimum lines number of a similarity. [default: 4]

       --ignore-comments=<y or n>
              Ignore comments when computing similarities. [default: yes]

       --ignore-docstrings=<y or n>
              Ignore docstrings when computing similarities. [default: yes]

       --ignore-imports=<y or n>
              Ignore imports when computing similarities. [default: no]

              Maximum number of arguments for function / method. [default: 5]

              Maximum number of locals for function / method  body.  [default:

              Maximum  number  of  return  / yield for function / method body.
              [default: 6]

              Maximum number of branch for function / method  body.  [default:

              Maximum   number  of  statements  in  function  /  method  body.
              [default: 50]

              Maximum number of parents for a class (see R0901). [default: 7]

              Maximum number of attributes for a class (see R0902).  [default:

              Minimum  number  of  public  methods  for  a  class (see R0903).
              [default: 2]

              Maximum number of  public  methods  for  a  class  (see  R0904).
              [default: 20]

              Maximum  number  of  boolean expressions in an if statement (see
              R0916). [default: 5]

              Good variable names which should always be  accepted,  separated
              by a comma. [default: i,j,k,ex,Run,_]

              Good  variable  names  regexes,  separated  by a comma. If names
              match any regex, they will always be accepted [default: none]

              Bad variable names which should always be refused, separated  by
              a comma. [default: foo,bar,baz,toto,tutu,tata]

              Bad variable names regexes, separated by a comma. If names match
              any regex, they will always be refused [default: none]

              Colon-delimited sets of names that determine each other's naming
              style  when  the  name  regexes  allow several styles. [default:

              Include a hint for the correct naming format with  invalid-name.
              [default: no]

       --property-classes=<decorator names>
              List   of   decorators   that   produce   properties,   such  as
              abc.abstractproperty. Add to this list to register other decora-
              tors  that  produce valid properties. These decorators are taken
              in consideration only for invalid-name. [default:  abc.abstract-

              Naming   style   matching   correct  argument  names.  [default:

              Regular expression matching correct  argument  names.  Overrides

              Naming   style   matching  correct  attribute  names.  [default:

              Regular expression matching correct attribute  names.  Overrides

              Naming style matching correct class names. [default: PascalCase]

              Regular  expression  matching  correct  class  names.  Overrides

              Naming style matching correct class attribute  names.  [default:

              Regular expression matching correct class attribute names. Over-
              rides class-attribute-naming-style.

              Naming  style  matching  correct   constant   names.   [default:

              Regular  expression  matching  correct constant names. Overrides

              Naming  style  matching  correct   function   names.   [default:

              Regular  expression  matching  correct function names. Overrides

              Naming style matching correct inline iteration names.  [default:

              Regular  expression  matching  correct  inline  iteration names.
              Overrides inlinevar-naming-style.

              Naming  style   matching   correct   method   names.   [default:

              Regular  expression  matching  correct  method  names. Overrides

              Naming  style   matching   correct   module   names.   [default:

              Regular expression matching correct module names. Overrides mod-

              Naming  style  matching  correct   variable   names.   [default:

              Regular  expression  matching  correct variable names. Overrides

              Regular expression which should only  match  function  or  class
              names that do not require a docstring. [default: ^_]

              Minimum  line  length  for  functions/classes  that require doc-
              strings, shorter ones are exempt. [default: -1]

              This flag controls whether the implicit-str-concat should gener-
              ate  a  warning  on  implicit  string concatenation in sequences
              defined over several lines. [default: no]

              This flag controls whether inconsistent-quotes generates a warn-
              ing  when the character used as a quote delimiter is used incon-
              sistently within a module. [default: no]

       The following environment variables are used:
           * PYLINTHOME
           Path to the directory where persistent data for  the  run  will  be
       stored.  If not found, it defaults to ~/.pylint.d/ or .pylint.d (in the
       current working directory).
           * PYLINTRC
           Path to the configuration  file.  See  the  documentation  for  the
       method used to search for configuration file.

       Using the default text output, the message format is :


       There are 5 kind of message types :
           * (C) convention, for programming standard violation
           * (R) refactor, for bad code smell
           * (W) warning, for python specific problems
           * (E) error, for probable bugs in the code
           * (F) fatal, if an error occurred which prevented pylint from doing
       further processing.

       Pylint should leave with following status code:
           * 0 if everything went fine
           * 1 if a fatal message was issued
           * 2 if an error message was issued
           * 4 if a warning message was issued
           * 8 if a refactor message was issued
           * 16 if a convention message was issued
           * 32 on usage error

       status 1 to 16 will be bit-ORed so you can know which  different  cate-
       gories has been issued by analysing pylint output status code

       See attributes(7) for descriptions of the following attributes:

       |Availability   | developer/python/pylint |
       |Stability      | Uncommitted             |


       Please  report  bugs  on  the project's mailing list: mailto:code-qual-

       Python Code Quality Authority <code-quality@python.org>

       Source code for open source software components in Oracle  Solaris  can
       be found at https://www.oracle.com/downloads/opensource/solaris-source-

       This    software    was    built    from    source     available     at
       https://github.com/oracle/solaris-userland.    The  original  community
       source was downloaded from  pypi:///pylint==2.6.0.

       Further information about this software can be found on the open source
       community website at https://www.pylint.org/.

pylint                            2020-03-13                         pylint(1)