PEP 8 -- Style Guide for Python Code - The Diigo Meta page

• 15 May 12
  

  Saverio Tassinari

  python programming

• 13 May 12
  

  David Warrington

  python style guide standards programming code

• 05 May 12
  

  Christopher Ivie

  python programming reference guide documentation standards

• 14 Apr 12
  

  ekondrashev
  • discouraged
  • insistent
  • controversy
  • mangled
  • beware

  3 more annotations...

• 12 Apr 12
  

  jrumball

  python programming reference documentation standards

• 02 Apr 12
  

  raywintergrafx

  Python naming convention.

  Knowledge Learning Python

• 31 Mar 12
  

  Matthew Plourde

  python style

• 22 Mar 12
  

  José Fernando Calcerrada

  PEP 8 -- Style Guide for Python Code

  python style-guide best-practices programming

• 12 Mar 12
  

  ruxin hou

  python coding style

• 20 Feb 12
  

  python pep guide style

• 07 Feb 12
  

  python rules

• 26 Jan 12
  

  sdxegoc

  python programming reference code pep documentation

• 16 Jan 12
  

  Rumayan Neykova
  • Package and Module Names
  • Modules should have short, all-lowercase names
  • Python packages should  also have short, all-lowercase names
  • Since module names are mapped to file names, and some file systems are  case insensitive and truncate long names
  • Class Names
  • Almost without exception, class names use the CapWords
  • Exception Names
  • suffix "Error"

  6 more annotations...

• 14 Jan 12
  

  Nicolas Palopoli

  This document gives coding conventions for the Python code comprising the standard library in the main Python distribution. Please see the companion informational PEP describing style guidelines for the C code in the C implementation of Python.
  
  This doc

  labo tips programming

• 12 Jan 12
  

  Grzegorz Wierzowiecki

  style-guide python vg programming team_programming business collaboration vgvg error_501 styleguide

• 10 Jan 12
  

  Matt Ritter

  ly are strongly recommended over tabs. Most
  editors have features that make this easy to do.
  
  Maximum Line Length
  
  Limit all lines to a maximum

• 04 Jan 12
  

  Daniel Ionescu

  python reference guide code pep style

• 02 Jan 12
  

  Alexey Tigarev

  python programming code guide pep standards documentation

• 11 Dec 11
  

  whereisfenners

  python programming SDD

• 06 Dec 11
  

  Thomas Maier

  Style Guide for Python Code

  python code style

• 05 Dec 11
  

  Mark Horvath

  python guide style code

  • CapWords
  • CapWords
  • CapWords
  • CapWords
  • Optional:  # Extra indentation is not necessary.  foo = long_function_name(  var_one, var_two,  var_three, var_four)
  • spaces only
  • Imports should be grouped in the following order:   1. standard library imports  2. related third party imports  3. local application/library specific imports   You should put a blank line between each group of imports.
  • Package and Module Names   Modules should have short, all-lowercase names. Underscores can be used  in the module name if it improves readability. Python packages should  also have short, all-lowercase names, although the use of underscores is  discouraged.
  • some file systems are  case insensitive and truncate long names, it is important that module  names be chosen to be fairly short
  • Class Names   Almost without exception, class names use the CapWords convention.
  • CapWords
  • lowercase, with words separated by underscores
  • Thus "print_" is better than  "prnt".
  • Method Names and Instance Variables
  • lowercase with words separated by  underscores
  • MAX_OVERFLOW

  14 more annotations...

• 26 Nov 11
  

  tevashov

  coding style python delicious

• 25 Nov 11
  

  beev20vtq

  programming python code documentation standards

• 11 Nov 11
  

  Ben Ceschi

  system:unfiled delicious

• 06 Nov 11
  

  Eapen G

  python programming reference guide pep documentation standards

• 03 Nov 11
  

  code standards programming python

• 02 Nov 11
  

  endlesscode

  python pep guide

• 22 Oct 11
  

  lifeonahilltop
  • Guido van Rossum
  • This document was adapted from Guido's original Python Style Guide  essay[2], with some additions from Barry's style guide[5].
  • code is read much more often than it  is written.
  • # Aligned with opening delimiter  foo = long_function_name(var_one, var_two,  var_three, var_four)
  • # More indentation included to distinguish this from the rest.  def long_function_name(  var_one, var_two, var_three,  var_four):  print(var_one)
  • Limit all lines to a maximum of 79 characters.
  • b (single lowercase letter)
  • B (single uppercase letter)
  • lowercase
  • lower_case_with_underscores
  • UPPERCASE
  • UPPER_CASE_WITH_UNDERSCORES
  • CapitalizedWords
  • When using abbreviations in CapWords, capitalize all the letters  of the abbreviation
  • mixedCase
  • Capitalized_Words_With_Underscores (ugly!)
  • using a short unique prefix to group related  names together
  • The X11 library uses a leading X for all its public functions. In Python,  this style is generally deemed unnecessary
  • _single_leading_underscore
  • weak "internal use" indicator
  • single_trailing_underscore_
  • by convention to avoid conflicts with  Python keyword
  • __double_leading_underscore
  • when naming a class attribute, invokes name  mangling
  • __double_leading_and_trailing_underscore__
  • Never use the characters `l' (lowercase letter el), `O' (uppercase  letter oh), or `I' (uppercase letter eye) as single character variable  names.
  • Modules should have short, all-lowercase names.
  • Underscores can be used  in the module name if it improves readability.
  • Python packages should  also have short, all-lowercase names
  • When an extension module written in C or C++ has an accompanying Python  module that provides a higher level (e.g. more object oriented)  interface, the C/C++ module has a leading underscore (e.g. _socket)
  • Almost without exception, class names use the CapWords convention.  Classes for internal use have a leading underscore in addition.
  • Modules that are designed for use via "from M import *" should use the  __all__ mechanism to prevent exporting globals
  • the older  convention
  • prefixing such globals with an underscore
  • Function names should be lowercase, with words separated by underscores
  • mixedCase is allowed only in contexts where that's already the  prevailing style
  • 'self' for the first argument to instance methods
  • 'cls' for the first argument to class methods
  • To avoid name clashes with subclasses, use two leading underscores to  invoke Python's name mangling rules.
  • double  leading underscores should be used only to avoid name conflicts with  attributes in classes designed to be subclassed.
  • Constants are usually defined on a module level and written in all  capital letters with underscores separating words. Examples include  MAX_OVERFLOW and TOTAL.

  39 more annotations...

• 16 Oct 11
  

  Pankaj

  python programming reference standards documentation guide

• 06 Oct 11
  

  python guide

• 29 Sep 11
  

  Chrissy B
• 27 Sep 11
  

  Dániel Varga

  python

• 

  Jochen Fromm

  python programming style pep bestpractice code guide

• 

  florentin s

  python style code

• 19 Sep 11
  

  jordan goss

  " This document gives coding conventions for the Python code comprising the standard library in the main Python distribution."

  python documentation reference standards programming

• 06 Sep 11
  

  kr behrman

  python standards

• 05 Sep 11
  

  M Magnus
  • Use one leading underscore only for non-public methods and instance  variables.
• 01 Sep 11
  

  Ben Turner

  python programming tutorial

• 23 Aug 11
  

  eebo grooven

  python programming reference documentation

• 

  Alfonso E.M.

  python style coding

• 03 Aug 11
  

  Kenzo Okamura

  python programming reference guide pep code documentation standards

• 30 Jul 11
  

  pfgomez

  dev python

• 07 Jun 11
  

  Naoj Gior

  python style reference

• 27 May 11
  

  online8

  programming python development tutorial

• 19 May 11
  

  Xavier Parcel

  PYTHON

• 16 May 11
  

  bob dobbs

  python programming style documentation reference standards

• 24 Apr 11
  

  Jordi Varela

  python code style documentation guide dev

• 22 Apr 11
  

  stopro

  python programming

• 18 Apr 11
  

  Stéphane Langlois

  python pep

• 13 Apr 11
  

  nikerym

  python documentation

• 12 Apr 11
  

  Joseph Mornin

  This document gives coding conventions for the Python code comprising the standard library in the main Python distribution. Please see the companion informational PEP describing style guidelines for the C code in the C implementation of Python[1]. This document was adapted from Guido's original Python Style Guide essay[2], with some additions from Barry's style guide[5]. Where there's conflict, Guido's style rules for the purposes of this PEP. This PEP may still be incomplete (in fact, it may never be finished <wink>).

  python programming style syntax

• 

  k k
  • Note that most  importantly, the """ that ends a multiline docstring should be on a line  by itself, and preferably preceded by a blank line, e.g.:   """Return a foobang   Optional plotz says to frobnicate the bizbaz first.   """
  • If you have to have Subversion, CVS, or RCS crud in your source file, do  it as follows.   __version__ = "$Revision: 64bda015861d $"  # $Source$   These lines should be included after the module's docstring, before any  other code, separated by a blank line above and b
  • Modules should have short, all-lowercase names. Underscores can be used  in the module name if it improves readability. Python packages should  also have short, all-lowercase names, although the use of underscores is  discouraged.
  • Since module names are mapped to file names, and some file systems are  case insensitive and truncate long names, it is important that module  names be chosen to be fairly short -- this won't be a problem on Unix,  but it may be a problem when the code is transported to older Mac or  Windows versions, or DOS.
  • When an extension module written in C or C++ has an accompanying Python  module that provides a higher level (e.g. more object oriented)  interface, the C/C++ module has a leading underscore (e.g. _socket).
  • Almost without exception, class names use the CapWords convention.  Classes for internal use have a leading underscore in addition.
  • Modules that are designed for use via "from M import *" should use the  __all__ mechanism to prevent exporting globals, or use the older  convention of prefixing such globals with an underscore (which you might  want to do to indicate these globals are "module non-public").
  • Function names should be lowercase, with words separated by underscores  as necessary to improve readability.   mixedCase is allowed only in contexts where that's already the  prevailing style (e.g. threading.py), to retain backwards compatibility.
  • Use one leading underscore only for non-public methods and instance  variables.   To avoid name clashes with subclasses, use two leading underscores to  invoke Python's name mangling rules.
  • Constants are usually defined on a module level and written in all  capital letters with underscores separating words. Examples include  MAX_OVERFLOW and TOTAL.

  8 more annotations...

• 28 Mar 11
  

  Peter Avalos

  python programming reference guide documentation standards

• 21 Mar 11
  

  anushaa

  python programming code pep guide

• 20 Mar 11
  

  Jan Beilicke

  python programming guide reference pep code documentation standards styleguide coding-guidelines

• 

  Jojo Pad

  python coding-style best-practices programming

• 16 Mar 11
  

  Simon Hedberg

  python guide documentation standards programming reference pep

• 23 Feb 11
  

  Unagi Ramen

  python codingstyle code style

• 16 Feb 11
  

  Cong Qiao

  python

• 09 Feb 11
  

  AnandavelMurugan Chandramohan

  python code style documentation

• 

  Eric Chen

  python reference guide documentation

• 08 Feb 11
  

  vincentnys
  • One of Guido's key insights is that code is read much more often than it  is written. The guidelines provided here are intended to improve the  readability of code
  • Two good reasons to break a particular rule:   (1) When applying the rule would make the code less readable, even for  someone who is used to reading code that follows the rules.   (2) To be consistent with surrounding code that also breaks it (maybe for  historic reasons)
  • invoking the Python command line interpreter with the -t option, it issues  warnings about code that illegally mixes tabs and spaces. When using -tt  these warnings become errors. These options are highly recommended!
  • Limit all lines to a maximum of 79 characters.
  • For flowing long blocks of text (docstrings or comments),  limiting the length to 72 characters is recommended.
  • Long lines can be  broken over multiple lines by wrapping expressions in parentheses.
  • Separate top-level function and class definitions with two blank lines.   Method definitions inside a class are separated by a single blank line.
  • For Python 3.0 and beyond,  UTF-8 is preferred over Latin-1, see PEP 3120.
  • HOULD use  English words wherever feasible (in many cases, abbreviations and  technical terms are used which aren't English)
  • Imports should usually be on separate lines, e.g.:   Yes: import os  import sys
  • Imports are always put at the top of the file, just after any module  comments and docstrings, and before module globals and constants.
  • 1. standard library imports  2. related third party imports  3. local application/library specific imports
  • You should put a blank line between each group of imports.
  • Always use the absolute package path for all imports.

  12 more annotations...

• 03 Feb 11
  

  newtover

  python styleguide standards

• 25 Jan 11
  

  python guide reference pep code standards documentation programming

• 

  leonardomartins

  programming python

• 17 Jan 11
  

  Augusto Elesbão

  python documentation standards

• 26 Dec 10
  

  Vince Aggrippino

  python programming documentation reference standards pep

• 17 Dec 10
  

  Travis Nations
• 13 Dec 10
  

  Dan McCrea

  python programming guide style-guide style guidlines

• 12 Dec 10
  

  jelabra

  python styleGuide coding programming

• 08 Dec 10
  

  Ximing Li
  • Hobgoblin
  • across the wide spectrum of
  • Readability counts

  1 more annotation...

• 02 Dec 10
  

  Zach Williams

  python pep8 style.guide styleguide

• 25 Nov 10
  

  Utkarsh Upadhyay

  style guide python code

• 19 Nov 10
  

  emmeics2

  style python reference documentation programming development guide pep standards code

• 04 Nov 10
  

  Greg

  python styleguide guide documentation bestpractices delicious

• 31 Oct 10
  

  thedevshow 5by5

  python documentation standards guide episode22

• 25 Oct 10
  

  Mr. Fabroa
  • Indentation
  • Use 4 spaces per indentation level
  • Never mix tabs and spaces.
  • second-most popular way is with tabs only.

  2 more annotations...

• 22 Oct 10
  

  Juanan Sánchez

  python programming style reference documentation

• 16 Oct 10
  

  Al Wong

  programming python

• 12 Oct 10
  

  Leandro Ardissone

  python

• 11 Oct 10
  

  alienspaces

  python style syntax programming guide coding documentation howto reference standard manual codingstyle convention guidelines pep8 styleguide

• 30 Sep 10
  

  D C

  convention manual standard tips toread pep guidelines conventions tutorial protectedpython documentation guide python

  python naming conventions reference pep

  • _single_leading_underscore: weak "internal use" indicator. E.g. "from M  import *" does not import objects whose name starts with an underscore.   - single_trailing_underscore_: used by convention to avoid conflicts with  Python keyword, e.g.   Tkinter.Toplevel(master, class_='ClassName')   - __double_leading_underscore: when naming a class attribute, invokes name  mangling (inside class FooBar, __boo becomes _FooBar__boo; see below).   - __double_leading_and_trailing_underscore__: "magic" objects or  attributes that live in user-controlled namespaces. E.g. __init__,  __import__ or __file__. Never invent such names; only use them  as documented.
  • Class Names   Almost without exception, class names use the CapWords convention.  Classes for internal use have a leading underscore in addition.
  • Function Names   Function names should be lowercase, with words separated by underscores  as necessary to improve readability.   mixedCase is allowed only in contexts where that's already the  prevailing style (e.g. threading.py), to retain backwards compatibility.
  • Function and method arguments   Always use 'self' for the first argument to instance methods.   Always use 'cls' for the first argument to class methods.   If a function argument's name clashes with a reserved keyword, it is  generally better to append a single trailing underscore rather than use  an abbreviation or spelling corruption. Thus "print_" is better than  "prnt". (Perhaps better is to avoid such clashes by using a synonym.)
  • Method Names and Instance Variables   Use the function naming rules: lowercase with words separated by  underscores as necessary to improve readability.   Use one leading underscore only for non-public methods and instance  variables.   To avoid name clashes with subclasses, use two leading underscores to  invoke Python's name mangling rules.   Python mangles these names with the class name: if class Foo has an  attribute named __a, it cannot be accessed by Foo.__a. (An insistent  user could still gain access by calling Foo._Foo__a.) Generally, double  leading underscores should be used only to avoid name conflicts with  attributes in classes designed to be subclassed.   Note: there is some controversy about the use of __names (see below).

  3 more annotations...

• 24 Sep 10
  

  marcu alexandru
• 23 Sep 10
  

  datadebrief

  python development

• 21 Sep 10
  

  icytop

  python programming style

• 07 Sep 10
  

  dirk_rodermund

  python style reference standards pep styleguide fromDeli

• 06 Sep 10
  

  Tom Kern

  python

• 23 Aug 10
  

  alanbuttcui

  python codestyle pep

• 04 Aug 10
  

  Steve Farkas

  bestpractices code coding design development dev documentation programming tips toread tutorial python guide reference software language standards style opensource

• 16 Jul 10
  

  Ajinkya Kulkarni

  python programming guide reference standards documentation pep code

• 12 Jul 10
  

  Buzz Lightyear
  • The preferred place to break around a binary operator is  *after* the operator, not before it.
• 09 Jul 10
  

  Juan Martín

  python programming style reference pep

• 26 Jun 10
  

  Pantelis Moukas

  python programming reference documentation guide

• 06 Jun 10
  

  keenhenry1109

  programming python coding style convention documentation

  • __double_leading_and_trailing_underscore__
  • "magic" objects or  attributes that live in user-controlled namespaces.
  • __init__,  __import__ or __file__
  • Almost without exception, class names use the CapWords convention.

  2 more annotations...

• 03 Jun 10
  

  kostas pramatias

  python programming reference guide code pep documentation standards

  • One of Guido's key insights is that code is read much more often than it  is written.
  • Never mix tabs and spaces.
  • Limit all lines to a maximum of 79 characters.
  • Always use the absolute package path for all imports.
  • Don't use spaces around the '=' sign when used to indicate a  keyword argument or a default parameter value.

  3 more annotations...

• 28 May 10
  

  Nathan Fritz

  Official style guide for Python.

  programming python reference

  • Use 4 spaces per indentation level.
  • ever mix tabs and spaces.
  • Limit all lines to a maximum of 79 characters.
  • Separate top-level function and class definitions with two blank lines.
  • Method definitions inside a class are separated by a single blank line.
  • Use blank lines in functions, sparingly, to indicate logical sections.

  4 more annotations...

• 25 May 10
  

  Chris 089
  • Use 4 spaces per indentation level.
  • The most popular way of indenting Python is with spaces only.
  • Code indented with a mixture  of tabs and spaces should be converted to using spaces exclusively. When  invoking the Python command line interpreter with the -t option, it issues  warnings about code that illegally mixes tabs and spaces. When using -tt  these warnings become errors. These options are highly recommended!
  • For new projects, spaces-only are strongly recommended over tabs.
  • Limit all lines to a maximum of 79 characters.
  • For flowing long blocks of text (docstrings or comments),  limiting the length to 72 characters is recommended.
  • Separate top-level function and class definitions with two blank lines.
  • Method definitions inside a class are separated by a single blank line.
  • All identifiers in the Python  standard library MUST use ASCII-only identifiers, and SHOULD use  English words wherever feasible (in many cases, abbreviations and  technical terms are used which aren't English).
  • Imports should usually be on separate lines
  • it's okay to say this though:   from subprocess import Popen, PIPE
  • Imports are always put at the top of the file, just after any module  comments and docstrings, and before module globals and constants.
  • Imports should be grouped in the following order
  • a blank line between each group of imports
  • Conventions for writing good documentation strings (a.k.a. "docstrings")  are immortalized in PEP 257 [3].
  • Modules should have short, all-lowercase names. Underscores can be used  in the module name if it improves readability.
  • Almost without exception, class names use the CapWords convention.
  • Function names should be lowercase, with words separated by underscores  as necessary to improve readability.
  • Always use 'self' for the first argument to instance methods.   Always use 'cls' for the first argument to class methods.
  • Method Names and Instance Variables   Use the function naming rules
  • Constants are usually declared on a module level and written in all  capital letters with underscores separating words.
  • If your public attribute name collides with a reserved keyword, append  a single trailing underscore to your attribute name. This is  preferable to an abbreviation or corrupted spelling.
  • For simple public data attributes, it is best to expose just the  attribute name, without complicated accessor/mutator methods.
  • use properties to hide functional  implementation behind simple data attribute access syntax
  • String exceptions in new code are forbidden, because this language  feature is being removed in Python 2.6
  • Modules or packages should define their own domain-specific base  exception class, which should be subclassed from the built-in Exception  class
  • When raising an exception, use "raise ValueError('message')" instead of  the older form "raise ValueError, 'message'".
  • When catching exceptions, mention specific exceptions  whenever possible instead of using a bare 'except:' clause.
  • Additionally, for all try/except clauses, limit the 'try' clause  to the absolute minimum amount of code necessary.

  27 more annotations...

• 23 May 10
  

  flyer AE
• 16 May 10
  

  Wan Ameil

  How to write in Python

  python documentation standards guide code reference

• 15 May 10
  

  molly vader

  python

Would you like to comment?

Join Diigo for a free account, or sign in if you are already a member.