首页 > 编程语言> > python的pep8编码规范和代码调试（pdb，ipdb，debug）

python的pep8编码规范和代码调试（pdb，ipdb，debug）

2020-04-21 10:02:25 作者：互联网

一、python的pep8编码规范

通常会听别人提到PEP8，但是具体指什么内容呢?《Python Enhancement Proposal #8》（8号python增强提案）又叫PEP8，它是针对python而编订的代码格式指南。

编程语言不是艺术，而是工作或者工具，所以整理并遵循一套编码规范十分必要。

1、每个缩进层级使用4个空格。
2、每行最多79个字符。
3、顶层的函数（def）或类（class）的定义之间空两行。
4、采用ASCII或UTF-8编码文件。（就是在里面表明编码格式，ASCII编码格式或者是UTF-8的编码格式）
5、在文件的顶端，注释和文档说明之下，每行每条import语句只导入一个模块，
同时要按标准库、第三方库和本地库的导入顺序进行分组。（标准库是下载python后就有的，也就是python自带的，要是需要下载，无论是pip还是其他，都是第三方库。而本地库就是自己创建的）
6、在小括号、中括号、大括号之间或者括号之前没有额外的空格
7、类(class)的命名采用驼峰命名法，如CamelCase；异常的定义使用Error前缀（如适用的话）；函数的命名采用下划线分隔的小写字母，如separateed_by_underscores;用下划线开头定义私有的属性或方法，如_private

自动检查代码标准的pep8工具

pep8会在哪里显示哪行哪里违反了pep8的，并为每个问题提供了其错误码，要是违反了那些必要的遵守规范，p便会爆出错误(以E开头的的错误码)，如果是细微的问题则会报警告(以W开头的
错误码)。跟在字母后面的3位数则是错误或者警告，可以从中看出大概的错误类别。例如以E2开
头的错误通常是与空格有关，以3开头的错误通常与空行有关，而以w6开头的警告则表明使用已
经废弃的功能。

1. 代码布局

1.1 缩进

每级缩进用4个空格
括号中使用垂直隐式缩进或悬挂缩进
不使用Tap，更不能混合使用Tap和空格

正确示范

# (垂直隐式缩进)对准左括号起的第一个字符
foo = long_function_name(var_one, var_two,
                         var_three, var_four)

# (悬挂缩进) 以行首字符为基准，缩进（一般情况只需一层缩进）
foo = long_function_name(
    var_one, var_two,
    var_three, var_four)

# (悬挂缩进) 但下面情况, 需再加多一层缩进，和函数体的语句块区分开
def long_function_name(
        var_one, var_two, var_three,
        var_four):
    print(var_one)

# 右括号回退
my_list = [
    1, 2, 3,
    4, 5, 6,
]
result = some_function_that_takes_arguments(
    'a', 'b', 'c',
    'd', 'e', 'f',
)123456789101112131415161718192021222324

错误示范

# 使用悬挂缩进时，第一行有参数。
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# 参数的悬挂缩进和后续代码块缩进不能区别。
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)

# 右括号不回退，不推荐
my_list = [
    1, 2, 3,
    4, 5, 6,
    ]

result = some_function_that_takes_arguments(
    'a', 'b', 'c',
    'd', 'e', 'f',
    )1234567891011121314151617181920

1.2 最大行宽

每行最大行宽不超过 79 个字符
无括号续行，可使用反斜杠
括号内续行不需要使用反斜杠

# 无括号续行， 可使用反斜杠
with open('/path/to/some/file/you/want/to/read') as file_1, \
     open('/path/to/some/file/being/written', 'w') as file_2:
    file_2.write(file_1.read())

# 括号内续行，尽量在运算符后再续行
class Rectangle(Blob):
    def __init__(self, width, height,
                 color='black', emphasis=None, highlight=0):
        if (width == 0 and height == 0 and
                color == 'red' and emphasis == 'strong' or
                highlight > 100):
            raise ValueError("sorry, you lose")
        if width == 0 and height == 0 and (color == 'red' or
                                           emphasis is None):
            raise ValueError("I don't think so, values are %s,%s"%                             (width, height))12345678910111213141516

1.3 空行

两行空行用于分割顶层函数和类的定义
单个空行用于分割类定义中的方法
函数内逻辑无关段落之间空一行；其他地方尽量不要再空行
虽然可以使用‘；’，但尽量不要把多个语句写在同一行
if/for/while语句中，即使执行语句只有一句，也必须另起一行

class A(object):     # 类的方法定义用单个空行分割
    def method1():
        pass

    def method2():
        pass

def method3():       # 两行空行分割顶层函数和类的定义
    pass12345678910

1.4 模块导入

导入的每个模块应该单独成行
导入顺序如下: 先标准库，再相关的第三方库，最后本地库。(导入不同类型的模块之间，要有空行分割，各组里面的模块顺序按首字母自上而下升序排列)

# 正确示范
import active   # 按模块首字母排序导入, 依此递推
import adidas
import create

# 错误示范
import sys, os, knife  # 错误：一行导入多模块

import create          # 错误：不按模块首字母导入
import active
import beyond1234567891011

1.5 字符串

单引号和双引号作用是一样的，但必须保证成对存在，不能夹杂使用。
(建议句子使用双引号, 单词使用单引号, 但不强制。)

# 单引号和双引号效果一样

name = 'JmilkFan'
name = "Hey Guys!"1234

1.6 表达式和语句中的空格

括号里边避免空格

spam(ham[1], {eggs: 2})        # 正确示范

spam( ham[ 1 ], { eggs: 2 } )  # 错误示范123

逗号，冒号，分号之前避免空格

if x == 4: print x, y; x, y = y, x       # 正确示范

if x == 4 : print x , y ; x , y = y , x  # 错误示范123

函数调用的左括号之前不能有空格

spam(1)
dct['key'] = lst[index]     # 正确示范

spam (1)
dct ['key'] = lst [index]   # 错误示范12345

赋值等操作符前后不能因为对齐而添加多个空格

x = 1                # 正确示范
y = 2
long_variable = 3

x             = 1    # 错误示范
y             = 2
long_variable = 31234567

二元运算符两边各放置一个空格

涉及 = 的复合操作符 ( += , -=等)
比较操作符 ( == , < , > , != , <> , <= , >= , in , not in , is , is not )
逻辑操作符( and , or , not )

a = b
a or b

# 括号内的操作符两边不需要空格
name = get_name(age, sex=None, city=Beijing)12345

1.7 注释

总体原则，错误的注释不如没有注释。所以当一段代码发生变化时，第一件事就是修改注释。

注释块
- 注释块通常应用在代码前，并和代码有同样的缩进。每行以 ‘# ’ 开头, 而且#后面有单个空格。段落之间以只有‘#’的行间隔

# Have to define the param `args(List)`, 
# otherwise will be capture the CLI option when execute `python manage.py server`.
# oslo_config: (args if args is not None else sys.argv[1:])
CONF(args=[], default_config_files=[CONFIG_FILE])1234

单行注释(这种方式尽量少使用)

x = x + 1 # Compensate for border1

文档字符串

# 多行文档, 首行首字母大写，结尾的 """ 应该单独成行
"""Return a foobang
Optional plotz says to frobnicate the bizbaz first.
"""

# 单行的文档， 结尾的 """ 在同一行。
"""Return a foobang"""1234567

为共有的模块、函数、类、方法写docstrings；非共有的没有必要写docstrings，但是可以写注释（在def的下一行）
应避免无谓的注释

1.8 命名规则

包和模块名
包和模块名应该简短，全部用小写字母, 多字母之间可以使用单下划线连接。
类名
遵循驼峰命名。

class MyClass(object):
    pass12

全局变量名
全局变量名应尽量只在模块内部使用, 对可能使用语句from moduleName import variableName而被导入的模块，应采用__all__机制来防止全局变量被别的模块导入, 或者在全局变量名开头加一个前置下划线。

_name = 'name'1

函数名
函数名应该为全部小写的凹驼峰规则。

vcenter_connection = ''1

常量名
常量全部使用大写字母的凹驼峰规则来表示, 通常在模块顶格定义。

MAX_OVERFLOW = ''
TOTAL = 112

方法名和实例变量
- 非公开方法和实例变量开头使用前置下划线
- 有时候可能会为了避免与子类命名冲突，采用两个前置下划线
  需要注意的是: 若 class Foo 的属性名为 a，该属性是不能以 Foo.a 的方式访问的(执著的用户还是可以通过Foo._Foo__a 来访问), 所以通常双前置下划线仅被用来避免与基类的属性发生命名冲突。

2. 编程建议

编码中应考虑到其他python实现的效率问题，比如运算符‘+’在CPython中效率很高，在Jython中却非常低
None 的比较用 is 或 is not，而不要用 ==；尽可能使用‘is’‘is not’取代‘==’；用 is not 代替 not … is, 前者的可读性更好

if foo is not None     # Yes

if not foo is None     # No123
if x is not None       # if x is not None 要优于if x

if x123

使用函数定义关键字 def 代替 lambda 赋值给标识符, 这样更适合于回调和字符串表示

def f(x):              # Yes
    return 2*x

f = lambda x: 2*x      # No1234

异常类应该继承自Exception，而不是 BaseException；捕获异常时尽量指明具体异常, 尽量不用 except Exception；应该捕获出了什么问题，而不是问题发生

try:                                   # Yes (捕获具体异常)
    import platform_specific_module    
except ImportError:
    platform_specific_module = None

try:                                   # No (不要全局捕获)
    import platform_specific_module
except:
    platform_specific_module = None123456789

try/except 子句中的代码要尽可能的少, 以免屏蔽掉其他的错误

try:                            # Yes
    value = collection[key]
except KeyError:
    return key_not_found(key)
else:
    return handle_value(value)

try:                            # No
    return handle_value(collection[key])
except KeyError:
    # 可能会捕捉到handle_value()中的 KeyError, 而不是collection的
    return key_not_found(key)12345678910111213

函数或者方法在没有返回值时要明确返回 None

def foo():        # Yes
    return None

def foo():        # No
    return12345

使用字符串方法而不是 string 模块
python 2.0 以后字符串方法总是更快，而且与 Unicode 字符串使用了相同的 API
使用使用 .startswith() 和 .endswith() 代替字符串切片来检查前缀和后缀
startswith() 和 endswith 更简洁，利于减少错误

if foo.startswith('bar'):   # Yes

if foo[:3] == 'bar':        # No123

使用 isinstance() 比较对象的类型

if isinstance(obj, int):   # Yes

if type(obj) is type(1):   # No123

判断序列空或不空
空序列类型对象的 bool 为 False:

if not seq:       # Yes
   pass
if seq:
   pass

if len(seq):      # No
   pass
if not len(seq):
   pass123456789

不要使用 == 进行 bool 比较

 # Yes
if greeting:          
   pass

# No
if greeting == True
   pass
if greeting is True: # Worse
   pass123456789

字符串不要以空格收尾
二进制数据判断使用if boolvalue的方式
使用Map和Reduce，不要使用循环

二、`pdb`代码调试

程序能一次写完并正常运行的概率很小，基本不超过1%。总会有各种各样的bug需要修正。有的bug很简单，看看错误信息就知道，有的bug很复杂，我们需要知道出错时，哪些变量的值是正确的，哪些变量的值是错误的，因此，需要一整套调试程序的手段来修复bug。

安装ipdb库

PS G:\四期\python> pip install pdb

G:\四期\python\4\1.py文件内容如下：

import pdb
s = '0'
n = int(s)
pdb.set_trace()
print(10/n)

调试一下

PS G:\四期\python\4> python 2.py
> g:\四期\python\4\2.py(5)<module>()
-> print(10/n)

1、使用pdb进行调试：

pdb 是 python 自带的一个包，为 python 程序提供了一种交互的源代码调试功能，主要特性包括设置断点、单步调试、进入函数调试、查看当前代码、查看栈片段、动态改变变量的值等。pdb 提供了一些常用的调试命令，详情见表 1。

pdb 常用命令

命令	解释
break 或 b 设置断点	设置断点
continue 或 c	继续执行程序
list 或 l	查看当前行的代码段
step 或 s	进入函数
return 或 r	执行代码直到从当前函数返回
exit 或 q	中止并退出
next 或 n	执行下一行
pp	打印变量的值
help	帮助

下面结合具体的实例讲述如何使用 pdb 进行调试。

2、测试代码示例

 import pdb 
 a = "aaa"
 pdb.set_trace() 
 b = "bbb"
 c = "ccc"
 final = a + b + c 
 print final

开始调试：直接运行脚本，会停留在 pdb.set_trace() 处，选择 n+enter 可以执行当前的 statement。在第一次按下了 n+enter 之后可以直接按 enter 表示重复执行上一条 debug 命令。

（1）利用 pdb 调试

[root@rcc-pok-idg-2255 ~]#  python epdb1.py 
 > /root/epdb1.py(4)?() 
 -> b = "bbb"
 (Pdb) n 
 > /root/epdb1.py(5)?() 
 -> c = "ccc"
 (Pdb) 
 > /root/epdb1.py(6)?() 
 -> final = a + b + c 
 (Pdb) list 
  1     import pdb 
  2     a = "aaa"
  3     pdb.set_trace() 
  4     b = "bbb"
  5     c = "ccc"
  6  -> final = a + b + c 
  7     print final 
 [EOF] 
 (Pdb) 
 [EOF] 
 (Pdb) n 
 > /root/epdb1.py(7)?() 
 -> print final 
 (Pdb)

退出 debug：使用 quit 或者 q 可以退出当前的 debug，但是 quit 会以一种非常粗鲁的方式退出程序，其结果是直接 crash。

（2）退出 debug

[root@rcc-pok-idg-2255 ~]#  python epdb1.py 
 > /root/epdb1.py(4)?() 
 -> b = "bbb"
 (Pdb) n 
 > /root/epdb1.py(5)?() 
 -> c = "ccc"
 (Pdb) q 
 Traceback (most recent call last): 
  File "epdb1.py", line 5, in ? 
    c = "ccc"
  File "epdb1.py", line 5, in ? 
    c = "ccc"
  File "/usr/lib64/python2.4/bdb.py", line 48, in trace_dispatch 
    return self.dispatch_line(frame) 
  File "/usr/lib64/python2.4/bdb.py", line 67, in dispatch_line 
    if self.quitting: raise BdbQuit 
 bdb.BdbQuit

打印变量的值：如果需要在调试过程中打印变量的值，可以直接使用 p 加上变量名，但是需要注意的是打印仅仅在当前的 statement 已经被执行了之后才能看到具体的值，否则会报 NameError: < exceptions.NameError … ....> 错误。

（3）debug 过程中打印变量

[root@rcc-pok-idg-2255 ~]#  python epdb1.py 
 > /root/epdb1.py(4)?() 
 -> b = "bbb"
 (Pdb) n 
 > /root/epdb1.py(5)?() 
 -> c = "ccc"
 (Pdb) p b 
'bbb'
 (Pdb) 
'bbb'
 (Pdb) n 
 > /root/epdb1.py(6)?() 
 -> final = a + b + c 
 (Pdb) p c 
'ccc'
 (Pdb) p final 
 *** NameError: <exceptions.NameError instance at 0x1551b710 > 
 (Pdb) n 
 > /root/epdb1.py(7)?() 
 -> print final 
 (Pdb) p final 
'aaabbbccc'
 (Pdb)

使用 c 可以停止当前的 debug 使程序继续执行。如果在下面的程序中继续有 set_statement() 的申明，则又会重新进入到 debug 的状态，读者可以在代码 print final 之前再加上 set_trace() 验证。

（4）停止 debug 继续执行程序

[root@rcc-pok-idg-2255 ~]#  python epdb1.py 
 > /root/epdb1.py(4)?() 
 -> b = "bbb"
 (Pdb) n 
 > /root/epdb1.py(5)?() 
 -> c = "ccc"
 (Pdb) c 
 aaabbbccc

显示代码：在 debug 的时候不一定能记住当前的代码块，如要要查看具体的代码块，则可以通过使用 list 或者 l 命令显示。list 会用箭头 -> 指向当前 debug 的语句。

（5）debug 过程中显示代码

[root@rcc-pok-idg-2255 ~]#  python epdb1.py 
 > /root/epdb1.py(4)?() 
 -> b = "bbb"
 (Pdb) list 
  1     import pdb 
  2     a = "aaa"
  3     pdb.set_trace() 
  4  -> b = "bbb"
  5     c = "ccc"
  6     final = a + b + c 
  7     pdb.set_trace() 
  8     print final 
 [EOF] 
 (Pdb) c 
 > /root/epdb1.py(8)?() 
 -> print final 
 (Pdb) list 
  3     pdb.set_trace() 
  4     b = "bbb"
  5     c = "ccc"
  6     final = a + b + c 
  7     pdb.set_trace() 
  8  -> print final 
 [EOF] 
 (Pdb)

在使用函数的情况下进行 debug

（6）使用函数的例子

import pdb 
 def combine(s1,s2):      # define subroutine combine, which... 
    s3 = s1 + s2 + s1    # sandwiches s2 between copies of s1, ... 
    s3 = '"' + s3 +'"'   # encloses it in double quotes,... 
    return s3            # and returns it. 
 a = "aaa"
 pdb.set_trace() 
 b = "bbb"
 c = "ccc"
 final = combine(a,b) 
 print final

如果直接使用 n 进行 debug 则到 final=combine(a,b) 这句的时候会将其当做普通的赋值语句处理，进入到 print final。如果想要对函数进行 debug 如何处理呢 ? 可以直接使用 s 进入函数块。函数里面的单步调试与上面的介绍类似。如果不想在函数里单步调试可以在断点处直接按 r 退出到调用的地方。

（8）对函数进行 debug

[root@rcc-pok-idg-2255 ~]# python epdb2.py 
 > /root/epdb2.py(10)?() 
 -> b = "bbb"
 (Pdb) n 
 > /root/epdb2.py(11)?() 
 -> c = "ccc"
 (Pdb) n 
 > /root/epdb2.py(12)?() 
 -> final = combine(a,b) 
 (Pdb) s 
 --Call-- 
 > /root/epdb2.py(3)combine() 
 -> def combine(s1,s2):      # define subroutine combine, which... 
 (Pdb) n 
 > /root/epdb2.py(4)combine() 
 -> s3 = s1 + s2 + s1    # sandwiches s2 between copies of s1, ... 
 (Pdb) list 
  1     import pdb 
  2 
  3     def combine(s1,s2):      # define subroutine combine, which... 
  4  ->     s3 = s1 + s2 + s1    # sandwiches s2 between copies of s1, ... 
  5         s3 = '"' + s3 +'"'   # encloses it in double quotes,... 
  6         return s3            # and returns it. 
  7 
  8     a = "aaa"
  9     pdb.set_trace() 
 10     b = "bbb"
 11     c = "ccc"
 (Pdb) n 
 > /root/epdb2.py(5)combine() 
 -> s3 = '"' + s3 +'"'   # encloses it in double quotes,... 
 (Pdb) n 
 > /root/epdb2.py(6)combine() 
 -> return s3            # and returns it. 
 (Pdb) n 
 --Return-- 
 > /root/epdb2.py(6)combine()->'"aaabbbaaa"'
 -> return s3            # and returns it. 
 (Pdb) n 
 > /root/epdb2.py(13)?() 
 -> print final 
 (Pdb)

在调试的时候动态改变值。在调试的时候可以动态改变变量的值，具体如下实例。需要注意的是下面有个错误，原因是 b 已经被赋值了，如果想重新改变 b 的赋值，则应该使用！ B。

（7）在调试的时候动态改变值

[root@rcc-pok-idg-2255 ~]# python epdb2.py 
 > /root/epdb2.py(10)?() 
 -> b = "bbb"
 (Pdb) var = "1234"
 (Pdb) b = "avfe"
 *** The specified object '= "avfe"' is not a function 
 or was not found along sys.path. 
 (Pdb) !b="afdfd"
 (Pdb)

补充

在命令行中进入调试模式的方法：python -m pdb demo.py
在调试模式中按一下Enter键表示执行一下上一条命令。
在ipython中使用PDB（体验更好）：%run -d demo.py

参考1

参考2

标签：python,ipdb,py,pdb,pep8,var,root,Pdb
来源： https://blog.51cto.com/14320361/2488895

python的pep8编码规范和代码调试（pdb，ipdb，debug）

一、python的pep8编码规范

自动检查代码标准的pep8工具

1. 代码布局

1.1 缩进

正确示范

错误示范

1.2 最大行宽

1.3 空行

1.4 模块导入

1.5 字符串

1.6 表达式和语句中的空格

括号里边避免空格

逗号，冒号，分号之前避免空格

函数调用的左括号之前不能有空格

赋值等操作符前后不能因为对齐而添加多个空格

二元运算符两边各放置一个空格

1.7 注释

1.8 命名规则

2. 编程建议

二、pdb代码调试

安装ipdb库

G:\四期\python\4\1.py文件内容如下：

调试一下

1、使用pdb进行调试：

pdb 常用命令

2、测试代码示例

（1）利用 pdb 调试

（2）退出 debug

（3）debug 过程中打印变量

（4）停止 debug 继续执行程序

（5）debug 过程中显示代码

（6）使用函数的例子

（8）对函数进行 debug

（7）在调试的时候动态改变值

补充

二、`pdb`代码调试