Yes: foo_bar(self, width, height, color='black', design=None,
                x='foo', emphasis=None, highlight=0)

         if (width == 0 and height == 0 and
             color == 'red' and emphasis == 'strong'):

    x = ('This will build a very long long '
         'long long long long long long string')

    Yes:  # See details at
          # http://www.example.com/us/developer/documentation/api/content/v2.0/csv_file_name_extension_full_specification.html

    No:  # See details at
         # http://www.example.com/us/developer/documentation/api/content/\
         # v2.0/csv_file_name_extension_full_specification.html     

    Yes: if foo:
             bar()
         while x:
             x = bar()
         if x and y:
             bar()
         if not x:
             bar()
         return foo
         for (x, y) in dict.items(): ...  

    No:  if (x):
             bar()
         if not(x):
             bar()
         return (foo)

   Yes:   # Aligned with opening delimiter
          foo = long_function_name(var_one, var_two,
                                   var_three, var_four)

          # Aligned with opening delimiter in a dictionary
          foo = {
              long_dictionary_key: value1 +
                                   value2,
              ...
          }

          # 4-space hanging indent; nothing on first line
          foo = long_function_name(
              var_one, var_two, var_three,
              var_four)

          # 4-space hanging indent in a dictionary
          foo = {
              long_dictionary_key:
                  long_dictionary_value,
              ...
          }

    No:    # Stuff on first line forbidden
          foo = long_function_name(var_one, var_two,
              var_three, var_four)

          # 2-space hanging indent forbidden
          foo = long_function_name(
            var_one, var_two, var_three,
            var_four)

          # No hanging indent in a dictionary
          foo = {
              long_dictionary_key:
                  long_dictionary_value,
                  ...
          }

    Yes: spam(ham[1], {eggs: 2}, [])

    No:  spam( ham[ 1 ], { eggs: 2 }, [])

    Yes: if x == 4:
             print x, y
         x, y = y, x

    No:  if x == 4 :
             print x , y
         x , y = y , x

    Yes: spam(1)

    no: spam (1)

    Yes: dict['key'] = list[index]

    No:  dict ['key'] = list [index]

    Yes: x == 1

    No:  x<1

    Yes: def complex(real, imag=0.0): return magic(r=real, i=imag)

    No:  def complex(real, imag = 0.0): return magic(r = real, i = imag)

    Yes:
         foo = 1000  # comment
         long_name = 2  # comment that should not be aligned

         dictionary = {
             "foo": 1,
             "long_name": 2,
             }

    No:
         foo       = 1000  # comment
         long_name = 2     # comment that should not be aligned

         dictionary = {
             "foo"      : 1,
             "long_name": 2,
             }

        def fetch_bigtable_rows(big_table, keys, other_silly_variable=None):
            """Fetches rows from a Bigtable.

            Retrieves rows pertaining to the given keys from the Table instance
            represented by big_table.  Silly things may happen if
            other_silly_variable is not None.

            Args:
                big_table: An open Bigtable Table instance.
                keys: A sequence of strings representing the key of each table row
                    to fetch.
                other_silly_variable: Another optional variable, that has a much
                    longer name than the other args, and which does nothing.

            Returns:
                A dict mapping keys to the corresponding table row data
                fetched. Each row is represented as a tuple of strings. For
                example:

                {'Serak': ('Rigel VII', 'Preparer'),
                 'Zim': ('Irk', 'Invader'),
                 'Lrrr': ('Omicron Persei 8', 'Emperor')}

                If a key from the keys argument is missing from the dictionary,
                then that row was not found in the table.

            Raises:
                IOError: An error occurred accessing the bigtable.Table object.
            """
            pass

        class SampleClass(object):
            """Summary of class here.

            Longer class information....
            Longer class information....

            Attributes:
                likes_spam: A boolean indicating if we like SPAM or not.
                eggs: An integer count of the eggs we have laid.
            """

            def __init__(self, likes_spam=False):
                """Inits SampleClass with blah."""
                self.likes_spam = likes_spam
                self.eggs = 0

            def public_method(self):
                """Performs operation blah."""

       # We use a weighted dictionary search to find out where i is in
       # the array.  We extrapolate position based on the largest num
       # in the array and the array size and then do binary search to
       # get the exact number.

       if i & (i-1) == 0:        # true if i is a power of 2

        # BAD COMMENT: Now go through the b array and make sure whenever i occurs
        # the next element is i+1

    Yes: class SampleClass(object):
             pass

         class OuterClass(object):

             class InnerClass(object):
                 pass

         class ChildClass(ParentClass):
             """Explicitly inherits from another class already."""

    No: class SampleClass:
            pass

        class OuterClass:

            class InnerClass:
                pass

    Yes: x = a + b
         x = '%s, %s!' % (imperative, expletive)
         x = '{}, {}!'.format(imperative, expletive)
         x = 'name: %s; score: %d' % (name, n)
         x = 'name: {}; score: {}'.format(name, n)

    No: x = '%s%s' % (a, b)  # use + in this case
        x = '{}{}'.format(a, b)  # use + in this case
        x = imperative + ', ' + expletive + '!'
        x = 'name: ' + name + '; score: ' + str(n)

    Yes: items = ['<table>']
         for last_name, first_name in employee_list:
             items.append('<tr><td>%s, %s</td></tr>' % (last_name, first_name))
         items.append('</table>')
         employee_table = ''.join(items)

    No: employee_table = '<table>'
        for last_name, first_name in employee_list:
            employee_table += '<tr><td>%s, %s</td></tr>' % (last_name, first_name)
        employee_table += '</table>'

   Yes:
        Python('Why are you hiding your eyes?')
        Gollum("I'm scared of lint errors.")
        Narrator('"Good!" thought a happy Python reviewer.')

   No:
        Python("Why are you hiding your eyes?")
        Gollum('The lint. It burns. It burns us.')
        Gollum("Always the great lint. Watching. Watching.")

    Yes:
        print ("This is much nicer.\n"
               "Do it this way.\n")

    No:
          print """This is pretty ugly.
      Don't do this.
      """

      with open("hello.txt") as hello_file:
          for line in hello_file:
              print line

      import contextlib

      with contextlib.closing(urllib.urlopen("http://www.python.org/")) as front_page:
          for line in front_page:
              print line

    # TODO(kl@gmail.com): Use a "*" here for string repetition.
    # TODO(Zeke) Change this to use relations.

    Yes: import os
         import sys

    No:  import os, sys

    import foo
    from foo import bar
    from foo.bar import baz
    from foo.bar import Quux
    from Foob import ar

    Yes:

      if foo: bar(foo)

    No:

      if foo: bar(foo)
      else:   baz(foo)

      try:               bar(foo)
      except ValueError: baz(foo)

      try:
          bar(foo)
      except ValueError: baz(foo)

    def main():
          ...

    if __name__ == '__main__':
        main()

try:
    ...
except Exception as xx:    
    ...