I have written some Python in which some lines exceed 80 characters in length, which is a threshold I need to stay under. How can I adapt my code to reduce line lengths?

How can I make my Python code stay under 80 characters a line?

While searching through a Python project, I found a few lines commented with `# noqa`.


    import sys
    sys.path.append(r&#39;C:\dev&#39;)
    import some_module   # noqa


What does `noqa` mean in Python? Is it specific to Python only?

What does &#39;# noqa&#39; mean in Python comments?

PEP8 clearly specifies 79 characters, however, PyCharm defaults to 120 and gives me the warning &quot;PEP8: line too long (... &gt; 120 characters)&quot;. 

Did previous versions of PEP8 use 120 and PyCharm not update its PEP8 checker? I couldn&#39;t find any previous versions of the PEP8 Guide, however, I can easily find previous version of the PEP8 Python scripts.

I&#39;m starting a new Python project and I&#39;m not sure which to use.

References:

http://legacy.python.org/dev/peps/pep-0008/

Why does PyCharm use 120 Character Lines even though PEP8 Specifies 79?

This is is just a curiosity with historical purposes:

I was wondering if someone knows why the very widely used (and core module) [logging][1]  doesn&#39;t follow the Python&#39;s [PEP-8 naming convention][2].

For instance, in

    &gt;&gt;&gt; import logging
    &gt;&gt;&gt; log = logging.getLogger(&quot;hello&quot;)

I would expect it to be `get_logger`, but it isn&#39;t.

When it comes to [function names][3], the PEP8 standard says:

&gt; mixedCase is allowed only in contexts where that&#39;s already the
&gt; prevailing style (e.g. threading.py), to retain backwards
&gt; compatibility.

Was that the case? If so, with what other `logging` thingy it had to maintain backwards compatibility? Or was it just that the developers of `logging` felt like using camel-case naming?

Of course, the module is well documented and is not a big deal **at all**. I&#39;m just curious.


  [1]: https://docs.python.org/2/library/logging.html#logging.getLogger
  [2]: http://www.python.org/dev/peps/pep-0008/#prescriptive-naming-conventions
  [3]: http://www.python.org/dev/peps/pep-0008/#function-names

How come the Python&#39;s logging module doesn&#39;t follow PEP8 conventions?

Why in this millennium should Python [PEP-8][1] specify a [maximum line length][2] of 79 characters?

Pretty much every code editor under the sun can handle longer lines.  What to do with wrapping should be the choice of the content consumer, not the responsibility of the content creator.

Are there any (legitimately) good reasons for adhering to 79 characters in this age?


  [1]: http://www.python.org/dev/peps/pep-0008/
  [2]: https://www.python.org/dev/peps/pep-0008/#maximum-line-length

Why does PEP-8 specify a maximum line length of 79 characters?

As PEP8 suggests keeping below the 80 column rule for your python program, how can I abide to that with long strings, i.e.

    s = &quot;this is my really, really, really, really, really, really, really long string that I&#39;d like to shorten.&quot;

How would I go about expanding this to the following line, i.e.

    s = &quot;this is my really, really, really, really, really, really&quot; + 
        &quot;really long string that I&#39;d like to shorten.&quot;

How to write very long string that conforms with PEP8 and prevent E501

The [python style guide][1] suggests to group imports like this:

&gt; Imports should be grouped in the following order:
&gt;
&gt;    1. standard library imports
&gt;    2. related third party imports
&gt;    3. local application/library specific imports

However, it does not mention anything how the two different ways of imports should be laid out:

    from foo import bar
    import foo

There are multiple ways to sort them (let&#39;s assume all those import belong to the same group):

* first `from..import`, then `import`

        from g import gg
        from x import xx
        import abc
        import def
        import x

* first `import`, then `from..import`

        import abc
        import def
        import x
        from g import gg
        from x import xx

- alphabetic order by module name, ignoring the kind of import

        import abc
        import def
        from g import gg
        import x
        from xx import xx

PEP8 does not mention the preferred order for this and the &quot;cleanup imports&quot; features some IDEs have probably just do whatever the developer of that feature preferred.

**I&#39;m looking for another PEP clarifying this or a relevant comment/email from the [BDFL][2]** (or another Python core developer). *Please don&#39;t post subjective answers stating your own preference.*


  [1]: http://www.python.org/dev/peps/pep-0008/#imports
  [2]: http://en.wikipedia.org/wiki/Guido_van_Rossum

What&#39;s the correct way to sort Python `import x` and `from x import y` statements?

I&#39;ve always thought of the `if not x is None` version to be more clear, but Google&#39;s [style guide][1] and [PEP-8][2] both use `if x is not None`. Are there any minor performance differences (I&#39;m assuming not), and is there any case where one really doesn&#39;t fit (making the other a clear winner for my convention)?*

*I&#39;m referring to any singleton, rather than just `None`.

&gt; ...to compare singletons like
&gt; None. Use is  or is not.


  [1]: https://google.github.io/styleguide/pyguide.html?showone=True/False_evaluations#True/False_evaluations
  [2]: https://www.python.org/dev/peps/pep-0008/#programming-recommendations

Python `if x is not None` or `if not x is None`?

I see on Stack Overflow and [PEP 8][1] that the recommendation is to use spaces only for indentation in Python programs.  I can understand the need for consistent indentation and I have felt that pain.

Is there an underlying reason for spaces to be preferred?  I would have thought that tabs were far easier to work with.

  [1]: http://www.python.org/dev/peps/pep-0008/


Why does Python pep-8 strongly recommend spaces over tabs for indentation?

I have a line of the following code (don&#39;t blame for naming conventions, they are not mine):

    subkeyword = Session.query(
        Subkeyword.subkeyword_id, Subkeyword.subkeyword_word
    ).filter_by(
        subkeyword_company_id=self.e_company_id
    ).filter_by(
        subkeyword_word=subkeyword_word
    ).filter_by(
        subkeyword_active=True
    ).one()

I don&#39;t like how it looks like (not too readable) but I don&#39;t have any better idea to limit lines to 79 characters in this situation. Is there a better way of breaking it (preferably without backslashes)?

How to break a line of chained methods in Python?

From reading PEP-8, I get it that you should put the closing parenthesis on the same line as the last argument in function calls:

    ShortName.objects.distinct().filter(
        product__photo__stockitem__isnull=False)

Probably, long expressions are best to avoid at all. But if it&#39;s undesirable, **how would you go about multiple chained method calls? Should the closing paren be on a new line?**

    ShortName.objects.distinct().filter(
        product__photo__stockitem__isnull=False
    ).values_list(&#39;value&#39;, flat=True)

What about no-arguments methods? **How to write them on multiple lines without referencing the intermediate return values?**

    ShortName.objects.distinct(
        ).filter().values() # looks ugly


----------

*Update*: There&#39;s a duplicate question of https://stackoverflow.com/questions/4768941/how-to-break-a-line-of-chained-methods-in-python. The [accepted answer][1] suggests a familiar from jQuery style of starting each new line with a dot. The author doesn&#39;t provide any reasons or authoritative references, so I&#39;d like to get a confirmation on such style or an alternative.


  [1]: https://stackoverflow.com/a/4768979/352796

Chained method calls indentation style in Python

I have read there are three ways for coding multi-line imports in python

With slashes:

    from Tkinter import Tk, Frame, Button, Entry, Canvas, Text, \
        LEFT, DISABLED, NORMAL, RIDGE, END

Duplicating senteces:
    
    from Tkinter import Tk, Frame, Button, Entry, Canvas, Text
    from Tkinter import LEFT, DISABLED, NORMAL, RIDGE, END

With parenthesis:
    
    from Tkinter import (Tk, Frame, Button, Entry, Canvas, Text,
        LEFT, DISABLED, NORMAL, RIDGE, END)

Is there a recomended format or a more elegant way for this statements?

Is there a recommended format for multi-line imports?

I know there are tools which validate whether your Python code is compliant with PEP8,  for example there is both [an online service](http://pep8online.com/) and [a python module](https://github.com/jcrocholl/pep8/).

However, I cannot find a service or module which can *convert* my Python file to a self-contained, PEP8 valid Python file. Does anyone know if there are any?  
*I assume it&#39;s feasible since PEP8 is all about the appearance of the code, right?*

Tool to convert Python code to be PEP8 compliant

Why does [PEP 8 recommend not having spaces around `=` in a keyword argument or a default parameter value][1]?

Is this inconsistent with recommending spaces around every other occurrence of `=` in Python code?

How is:
    
    func(1, 2, very_long_variable_name=another_very_long_variable_name)

better than:

    func(1, 2, very_long_variable_name = another_very_long_variable_name)

Any links to discussion/explanation by Python&#39;s [BDFL](http://en.wikipedia.org/wiki/Benevolent_Dictator_for_Life) will be appreciated.

Mind, this question is more about kwargs than default values, i just used the phrasing from PEP 8.

I&#39;m not soliciting opinions. I&#39;m asking for reasons behind this decision. It&#39;s more like asking **why** would I use `{` on the same line as `if` statement in a C program, not **whether** I should use it or not.


  [1]: http://www.python.org/dev/peps/pep-0008/#other-recommendations

PEP 8, why no spaces around &#39;=&#39; in keyword argument or a default parameter value?

How are you supposed to break up a very long list comprehension?

    [something_that_is_pretty_long for something_that_is_pretty_long in somethings_that_are_pretty_long]

I have also seen somewhere that people that dislike using &#39;\&#39; to break up lines,
but never understood why. What is the reason behind this?

Line continuation for list comprehensions or generator expressions in python

When using PyCharm IDE the use of `except:` without an exception type triggers a reminder from the IDE that this exception clause is `Too broad`. 

Should I be ignoring this advice? Or is it Pythonic to always specific the exception type?

Should I always specify an exception type in `except` statements?

# Problem
PEP8 has a rule about putting imports at the top of a file:

&gt; Imports are always put at the top of the file, just after any module comments and docstrings, and before module globals and constants.

However, in certain cases, I might want to do something like:

    import sys
    sys.path.insert(&quot;..&quot;, 0)
    
    import my_module

In this case, the `pep8` command line utility flags my code:

&gt; E402 module level import not at top of file

What is the best way to achieve PEP8 compliance with `sys.path` modifications?

# Why

I have this code because I&#39;m following [the project structure](https://github.com/kennethreitz/samplemod) given in [The Hitchhiker&#39;s Guide to Python](http://docs.python-guide.org/en/latest/writing/structure/#structure-of-the-repository).

That guide suggests that I have a `my_module` folder, separate from a `tests` folder, both of which are in the same directory. If I want to access `my_module` from `tests`, I think I need to add `..` to the `sys.path`


PEP8 –&#160;import not at top of file with sys.path

In a block comment, I want to reference a URL that is over 80 characters long.

What is the preferred convention for displaying this URL?

I know bit.ly is an option, but the URL itself is descriptive. Shortening it and then having a nested comment describing the shortened URL seems like a crappy solution.

How should I format a long url in a python comment and still be PEP8 compliant

[PEP 8](http://www.python.org/dev/peps/pep-0008/) states:

&gt; Imports are always put at the top of the file, just after any module comments and docstrings, and before module globals and constants.

However if the class/method/function that I am importing is only used in rare cases, surely it is more efficient to do the import when it is needed?

Isn&#39;t this:

    class SomeClass(object):

        def not_often_called(self)
            from datetime import datetime
            self.datetime = datetime.now()

more efficient than this?

    from datetime import datetime
    
    class SomeClass(object):
    
        def not_often_called(self)
            self.datetime = datetime.now()

Should import statements always be at the top of a module?

I tried with

    #:PEP8 -E223

or

    # pep8: disable=E223

I thought the second would work but doesn&#39;t seems to work.

Do you have an idea how I can handle this ?

How to disable a pep8 error in a specific file?

I have defined a function with a long list of arguments. The total characters in definition is above 80 and doesn&#39;t abide by PEP8.

    def my_function(argument_one, argument_two, argument_three, argument_four, argument_five):

What can be the best approach to avoid horizontal scrolling?

Define functions with too many arguments to abide by PEP8 standard

A little background:

  - [PEP 8][1] is the *Style Guide for Python Code*. It contains the conventions all python programmers should follow.
  - [pep8.py][2] is a (very useful) script that checks the code formating of a given python script, according to PEP 8.
  - [Eclipse][3] is a great IDE. With the [Pydev][4] extension, it that can be used to develop Python

I run pep8.py manually when I&#39;m scripting, but with bigger projects I prefer to use Eclipse.
It would be really useful to integrate pep8.py in Eclipse/Pydev, so it can be run automatically in all the files in the project, and point to the lines containing the warnings.
Maybe there is an obvious way to do it, but I haven&#39;t found it yet.

Question is: **How to integrate pep8.py in Eclipse?**


  [1]: http://www.python.org/dev/peps/pep-0008/
  [2]: http://pypi.python.org/pypi/pep8
  [3]: http://www.eclipse.org/
  [4]: http://pydev.sourceforge.net/

How to integrate pep8.py in Eclipse?

I&#39;m doing PEP8 checks in python using the python [flake8][1] library. I have an import statement in an `__init__.py` file in one of my sub-modules which looks like this:

    from .my_class import MyClass

The reason I have this line in the init file is so that I can import MyClass from the sub-module as `from somemodule import MyClass` instead of having to write `from somemodule.my_class import MyClass`.

I would like to know if it is possible to maintain this functionality while correcting the PEP8 violation?


  [1]: https://pypi.python.org/pypi/flake8

python pep8 class in init imported but not used

[PEP8][1] suggests that:

&gt; Imports should be grouped in the following order:
&gt; 
&gt; 1. standard library imports 
&gt; 2. related third party imports 
&gt; 3. local application/library specific imports
&gt;
&gt; You should put a blank line between each group of imports.

Is there a way to check if the standard is violated anywhere in the package using static code analysis tools, like `pylint`, `pyflakes`, `pychecker`, `pep8`?

----------

Example of violation:

    from my_package import my_module
    from django.db import models
    import os

Correct way to import:

    import os

    from django.db import models

    from my_package import my_module

  [1]: http://www.python.org/dev/peps/pep-0008/#id16

Import order coding standard

While coding python I&#39;m using only 2 spaces to indent, sure [PEP-8][1] really recommend to have 4 spaces, but historically for me it&#39;s unusual.

So, can anyone convince me to use 4 spaces instead of 2? What pros and cons?

P.S. And finally, what&#39;s easy way to convert all existing codebase from 2 spaces to 4 spaces?

_____

P.P.S. PEP-8 Also srictly recommend not using tabs for indention. [read here][2]
____
So, to summarize:

   Pros:

  - Have more space to arrange when wraping string more than 80 lines long.
  - Can copy code from snippets and it just works.

Cons: 

  - With deeper level of nested statements you have less space for actual code.



Thanks.

  [1]: http://www.python.org/dev/peps/pep-0008/
  [2]: https://stackoverflow.com/questions/120926/why-does-python-pep-8-strongly-recommend-spaces-over-tabs-for-indentation

Python: using 4 spaces for indentation. Why?

I would like to get some feedback on these tools on:

- features;
- adaptability;
- ease of use and learning curve.



Pylint, PyChecker or PyFlakes?

some piece of my codes:

    
    
                if self.tagname and self.tagname2 in list1:
                    try: 
                        question = soup.find(&quot;div&quot;, &quot;post-text&quot;)
                        title = soup.find(&quot;a&quot;, &quot;question-hyperlink&quot;)
                        self.list2.append(str(title)+str(question)+url)
                        current += 1
                    except AttributeError:
                        pass			
                logging.info(&quot;%s questions passed, %s questions \
                    collected&quot; % (count, current))
                count += 1
            return self.list2
    
pep8 warning is:

    trailing whitespace 37:try
    trailing whitespace 43:pass

Can you please tell me what is this?

what is trailing whitespace and how can I handle this?

I am interested in knowing what is the Python convention for newlines between the program parts? For example, consider this:

    import os
    
    def func1():
    
    def func2():

What should be the ideal newline separation between:

 1. The `import` modules and the
    functions?
 2. The functions themselves? 

I have read [PEP8][1], but I wanted to confirm the above two points.


  [1]: https://www.python.org/dev/peps/pep-0008/

Python PEP8: Blank lines convention

Why is pep8 complaining on the next string in the code?

    import re
    re.compile(&quot;\d{3}&quot;)
The warning I receive:

    ID:W1401  Anomalous backslash in string: &#39;\d&#39;. String constant might be missing an r prefix.
Can you explain what is the meaning of the message? What do I need to change in the code so that the warning *W1401* is passed?

The code passes the tests and runs as expected. Moreover `\d{3}` is a valid regex.

pep8 warning on regex string in Python, Eclipse

I have a list of functions that may fail and, if one fails, I don&#39;t want the script to stop, but to continue with next function.

I am executing it with something like this :

    list_of_functions = [f_a, f_b, f_c]
    for current_function in list_of_functions:
        try:
            current_function()
        except Exception:
            print(traceback.format_exc())

It&#39;s working fine, but it is not PEP8 compliant:

&gt; When catching exceptions, mention specific exceptions whenever
&gt; possible instead of using a bare except: clause.
&gt; 
&gt; For example, use:
&gt; 
&gt;     try:
&gt;         import platform_specific_module
&gt;     except ImportError:
&gt;         platform_specific_module = None
&gt; 
&gt; A bare except: clause will catch SystemExit and KeyboardInterrupt
&gt; exceptions, making it harder to interrupt a program with Control-C,
&gt; and can disguise other problems. If you want to catch all exceptions
&gt; that signal program errors, use except Exception: (bare except is
&gt; equivalent to except BaseException: ).
&gt; 
&gt; A good rule of thumb is to limit use of bare &#39;except&#39; clauses to two
&gt; cases:
&gt; 
&gt;  If the exception handler will be printing out or logging the traceback; at least the user will be aware that an error has occurred.
&gt;
&gt;  If the code needs to do some cleanup work, but then lets the exception propagate upwards with raise . try...finally can be a better
&gt; way to handle this case.

How can I do this the good way?

How to prevent &quot;too broad exception&quot; in this case?

I have some code like this. Should the break occur before the periods or after?

    # before
    my_var = somethinglikethis.where(we=do_things).where(we=domore).where(we=everdomore)
    
    # this way
    my_var = somethinglikethis.where(we=do_things) \
                              .where(we=domore) \
                              .where(we=everdomore)
    
    # or this way
    my_var = somethinglikethis.where(we=do_things). \
                               where(we=domore). \
                               where(we=everdomore)



Correct style for line breaks when chaining methods in Python

What is the best way to format following piece of code accordingly to PEP8:

    oauth_request = oauth.OAuthRequest.from_consumer_and_token(consumer,
        token=token, verifier=verifier, http_url=ACCESS_TOKEN_URL)

The problem is that if I place more than one parameter on the first line, the line exceeds 79 characters. If I place each of the parameters on a separate line with 4 spaces indentation it looks quite ugly:

    oauth_request = oauth.OAuthRequest.from_consumer_and_token(
        consumer,
        token=token,
        verifier=verifier,
        http_url=ACCESS_TOKEN_URL)

The best option that I come up with is to add extra indentation for better distinguishing:

    oauth_request = oauth.OAuthRequest.from_consumer_and_token(
                            consumer,
                            token=token,
                            verifier=verifier,
                            http_url=ACCESS_TOKEN_URL)

I try to work out a general rule for me to use it for methods with long invocation on the first line and several parameters that can&#39;t fit a single line.

Python function argument list formatting

Just opened a file with Sublime Text (with Sublime Linter) and noticed a PEP8 formatting error that I&#39;d never seen before. Here&#39;s the text:

    urlpatterns = patterns(&#39;&#39;,
        url(r&#39;^$&#39;, listing, name=&#39;investment-listing&#39;),
    )

It&#39;s flagging the second argument, the line that starts `url(...)`

I was about to disable this check in ST2 but ***I&#39;d like to know what I&#39;m doing wrong*** before I ignore it. You never know, if it seems important I might even change my ways :)

What is PEP8&#39;s E128: continuation line under-indented for visual indent?

I am using PyCharm on Windows and want to change the settings to limit the maximum line length to `79` characters, as opposed to the default limit of `120` characters.

Where can I change the maximum amount of characters per line in PyCharm?

How do I set the maximum line length in PyCharm?

I found some old Python code that was doing something like:

    if type(var) is type(1):
       ...

As expected, `pep8` complains about this recommending usage of `isinstance()`.

Now, the problem is that the `numbers` module was added in Python 2.6 and I need to write code that works with Python 2.5+

So `if isinstance(var, Numbers.number)` is not a solution. 

Which would be the proper solution in this case? 


How to properly use python&#39;s isinstance() to check if a variable is a number?

So which is better and why?

```py
def my_function():
```

or

```py
def myFunction():
```

Should I use &quot;camel case&quot; or underscores in Python?

How does one format a long assert statement that complies with PEP8? Please ignore the contrived nature of my example.

    def afunc(some_param_name):
        assert isinstance(some_param_name, SomeClassName), &#39;some_param_name must be an instance of SomeClassName, silly goose!&#39;

One cannot wrap it in parenthesis, because that changes the behavior of the assert statement since it is a keyword, not a builtin function.

All Pep8 Solutions on Gang of Coders

Total of 37 Pep8 Solutions