Python 进阶 (十)Python 编程规范

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')

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

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

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

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

       # 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,           ...       }

# Stuff on first line forbiddenfoo = long_function_name(var_one, var_two,    var_three, var_four)
# 2-space hanging indent forbiddenfoo = long_function_name(  var_one, var_two, var_three,  var_four)
# No hanging indent in a dictionaryfoo = {    long_dictionary_key:        long_dictionary_value,        ...}

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

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

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

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

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

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

     foo = 1000  # comment     long_name = 2  # comment that should not be aligned     dictionary = {         "foo": 1,         "long_name": 2,         }

     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):        self.likes_spam = likes_spam        self.eggs = 0
    def public_method(self)：

'# 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 iff 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

class SampleClass(object):         pass     class OuterClass(object):         class InnerClass(object):             pass     class ChildClass(ParentClass):         """Explicitly inherits from another class already."""

class SampleClass:        pass    class OuterClass:        class InnerClass:            pass

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

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

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)

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>'

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

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

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

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

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

contextlib.closing():import contextlibwith contextlib.closing(urllib.urlopen("http://www.python.org/")) as front_page:    for line in front_page:        print lineLegacy AppEngine 中Python 2.5的代码如使用”with”语句, 需要添加 “from __future__ import with_statement”.

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

import osimport sys

import os, sys

import foofrom foo import barfrom foo.bar import bazfrom foo.bar import Quuxfrom Foob import ar

  if foo: bar(foo)

  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()