精华内容
下载资源
问答
  • Python 编码规范

    2018-03-07 19:10:50
    Python 编码规范Python 编码规范Python 编码规范Python 编码规范Python 编码规范
  • PEP8Python 编码规范

    2017-11-07 13:18:27
    PEP8Python 编码规范 将Python 的英文编码变成中文的数据规范
  • python编码规范

    万次阅读 多人点赞 2019-08-14 16:30:16
    一、python编码规范: (一)代码编码: 1、国际惯例,文件编码和 Python 编码格式全部为 utf-8 ,例如:在 Python 代码的开头,要统一加上 # -- coding: utf-8 --。 2、Python 代码中,非 ascii 字...

    PE8基本规范:

    建议修改在使用的 IDE 中修改 PEP8 的每行字数不超79字符规范,可修改为 Django 建议的 119 字符

    一、python编码规范:

    (一)代码编码:

    1、国际惯例,文件编码和 Python 编码格式全部为 utf-8 ,例如:在 Python 代码的开头,要统一加上 # -- coding: utf-8 --。
    2、Python 代码中,非 ascii 字符的字符串,请需添加u前缀
    3、若出现 Python编 码问题,可按照以下操作尝试解决:

    import sys
    reload(sys)
    sys.setdefaultencoding('utf-8')
    

    (二)命名规范:
    1、包名、模块名、局部变量名、函数名

      全小写+下划线式驼峰 示例:this_is_var
    

    2、全局变量

    全大写+下划线式驼峰 示例:GLOBAL_VAR
    

    3、类名

    首字母大写式驼峰 示例:ClassName()
    

    4、变量名命名

    尽量体现变量的数据类型和具体意义
    

    注:

    变量名、类名取名必须有意义,严禁用单字母
    变量名不要用系统关键字,如 dir type str等等
    

    建议:

    bool变量一般加上前缀 is_ 如:is_success
    

    (三)、import 顺序:

    1、标准库   2、第三方库  3、项目本身
    (之间用空行分隔)
    

    (四)、models 内部定义顺序:

    All database fields
    Custom manager attributes
    class Meta
    def (str)
    def save()
    def get_absolute_url()
    Any custom methods
    

    (五)、异常捕获处理原则:

    尽量只包含容易出错的位置,不要把整个函数 try catch
    对于不会出现问题的代码,就不要再用 try catch了
    只捕获有意义,能显示处理的异常
    能通过代码逻辑处理的部分,就不要用 try catch
    异常忽略,一般情况下异常需要被捕获并处理,但有些情况下异常可被忽略,只需要用 log 记录即可,可参考一下代码:

    def ignored():
        try:
            yield
        except Exceptions as e:
            logger.warning(e)
            pass
    

    (六)、return early原则

    提前判断并 return,减少代码层级,增强代码可读性(简单逻辑往前放)

    if not condition:
        return
    # a lot if code
    

    (七)、Fat model, thin view

    逻辑代码和业务代码解耦分离,功能性函数以及对数据库的操作定义写在 models 里面,业务逻辑写在 view 里面。

    (八)、权限校验装饰器异常抛出问题

    建议权限不足时直接抛出异常,可以使用 django 自带的:

    from django.core.exceptions import PermissionDenied
    

    权限不足时抛出异常 PermissionDenied,之后应该返回什么样的页面由 handler 或者中间件去处理

    (九)、分 method 获取 request 参数问题

    一般可以分method 获取request参数,这样能够使代码更可读,且之后修改 method 时不必每个参数都修改

    args = request.GET if request.method == "GET" else request.POST
    business_name = args.get('business_name', '')
    template_name = args.get('template_name', '')
    

    (十)、使用数字、常量表示状态

    两种的话改为 true/false,多种改为 enum 可读性更好

    def enum(**enums):
        return type("Enum", (), enums)
    
    StatusEnum = enum(
        SUCCESS=True,
        FAIL=False,
    )
    

    (十一)、其他注意问题

    1、【必须】去除代码中的 print,否则导致正式和测试环境 uwsgi 输出大量信息
    2、逻辑块空行分隔
    3、变量和其使用尽量放到一起
    4、【必须】 import过长,要放在多行的时候,使用 from xxx import(a, b, c),不要用 \ 换行
    5、Django Model 定义的 choices 直接在定义在类里面
    

    二、前端编码规范:

    (一):命名规则

    1、类的基础命名方式:“项目英文简写-当前页-页面内容块”如 .ijobs-index-box。
    2、Id 的基础命名方式:语义化,并使用下滑杠连接,如步骤名称可命名为 #step_name
    3、Javascript 变量命名方式:按照变量类型的首个字母为前缀,使用驼峰命名法;
    例子:

    var aName = ['zhangsan','lizi','zhaowu'];  //Array 数组
    var oBtn = window.document.getElementById('btn');  //Object 对象
    function fnName(){};  //Function 函数
    var nAge = 25;  //Integer(int) 整型
    var sWebURL="www.wangyingran.com";  //String 字符串
    

    三、日志规范:

    (一)日志输出级别:
    
    1、Error:系统异常,影响用户使用,必须通知到开发者及时修复。
    2、Warning:系统异常,不影响用户使用,但有异常需要跟进修复。
    3、Info:系统流水日志或日常记录,不做通知配置。
    

    (二)、日志输出格式:

    1、日志需要包含当前函数名,方便查找和定位。
    2、重要操作流水直接记录数据库,可以保存较长时间。
    3、错误日志要方便定位问题,建议记录当前参数以及上下文变量。
    

    四、代码提交规范

    每次代码提交必须有备注说明,注明本次提交做了哪些修改
    commit 分类:

    bugfix: -------- 线上功能 bug
    sprintfix: ----- 未上线代码修改 (功能模块未上线部分bug)
    minor: --------- 不重要的修改(换行,拼写错误等)
    feature: ----- 新功能说明
    

    五、接口规范

    Api 的 method:

    Api 的 method,要根据实际请求的类型,查询一定要用 get,不能随意指定 method。
    具体可以参考文档 《RESTful Web Services Cookbook-cn.pdf》 。
    

    接口返回内容

    接口返回内容开发建议直接参考蓝鲸 apigateway 规范,返回的内容中包含 result code data message request_id 这几个字段
    在这里插入图片描述
    接口返回Status Code

    **建议充分利用 HTTP Status Code 作为响应结果的基本状态码,基本状态码不能区分的 status,
    再用响应 body 中"约定"的 code 进行补充
    
    http状态码详细说明请参考: https://zh.wikipedia.org/wiki/HTTP%E7%8A%B6%E6%80%81%E7%A0%81**
    

    在这里插入图片描述

    接口数据验证

    数据检验逻辑"应当"和业务逻辑分离,这样做的好处:

    代码逻辑更加清晰
    数据校验逻辑(可能)可以复用

    分离方案:

    1)form-data/url-params:Django-Form 
    2)Json:Json-schema
    

    代码注释

    Python 代码注释
    方法必须使用标注注释,如果是公有方法或对外提供的 API 相关方法,则最好给出使用样例。如:
    在这里插入图片描述
    Module注释:在开头要加入对该模块的注释。如:
    在这里插入图片描述
    普通代码注释应该以‘#’和单个空格开始。

    如果有需要调整或者需要优化的地方,可以使用 #TODO 这里是注释内容”进行注释,

    格式:'#'+单个空格+'TODO'+单个空格+注释内容。
    

    方法的返回,如果数据结构比较复杂,则必须要对返回结果的每个属性做解释。

    前端代码注释

    Html 注释:

    <!-- 容器 -->
    <div class=“container”>
    ...
    <!-- 用户名 -->
    <div id=“user_name”>
    ...
    </div>
    <!-- /用户名 -->
    ...
    </div>
    <!-- /容器 -->
    

    css 注释
    内容比较少是可以只在顶部加注释,内容比较多时在尾部加结束标签/* 注释内容 end */

    /* 新建任务 start */
    .new-task{}
    /* 新建任务名 */
    .task-name{color:#333;}
    /* 新建任务时间 */
    .task-created-time{background:url(img/clock.png) no-repeat;}
    /* 新建任务 end */
    

    Js 注释
    Js注释同上,函数如果有参数,建议简单备注一下参数的内容和类型。

    文件或包的引用

    Python 代码:
    模块或包的引入最好使用完整路径,即使是同一个包下的相互引用,也建议使用完整路径。
    这样比较方便代码阅读,同时若后续需修改为相对路径也很简单。

    前端页面:
    在页面中引用 css 和 js、或配置 url 路径时,必须使用“绝对路径”,而不要使用‘…/’,‘./’等相对路径的引用方式

    展开全文
  • Python编码模式

    万次阅读 2018-03-20 22:31:12
    Python 编码模式 新建文件模板 README.md 重设系统编码 log设置与使用 config使用 缓存的使用 异常的使用 异常和日志的组合 语法杂项 docstring doctest 样式:PEP8 import this:Python 之禅 Python 编码...

    Python 编码模式

    新建文件模板

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-

    README.md

    简述系统内容,可以使用markdown语法自定义格式

    重设系统编码

    import sys
    
    try:
    reload(sys)
        sys.setdefaultencoding('utf-8')
    except NameError:
        # The only supported default encodings in Python are:
    
        #  Python 2.x: ASCII
        #  Python 3.x: UTF-8
        # So no need to sys.setdefaultencoding('utf-8')
        pass # py3

    log设置与使用

    1. logging.conf 配置命令行和文件的日志读写
    [loggers]
    keys=root,kol
    
    [handlers]
    keys=consoleHandler,fileHandler
    
    [formatters]
    keys=simpleFormatter
    
    [logger_root]
    level=DEBUG
    handlers=consoleHandler
    
    [logger_kol]
    level=DEBUG
    handlers=consoleHandler,fileHandler
    qualname=kol
    propagate=0
    
    [handler_consoleHandler]
    class=StreamHandler
    level=DEBUG
    formatter=simpleFormatter
    args=(sys.stdout,)
    
    [handler_fileHandler]  
    class=logging.handlers.RotatingFileHandler  
    level=DEBUG  
    formatter=simpleFormatter  
    args=('kol.log','a',20000,5,)
    
    [formatter_simpleFormatter]
    format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
    datefmt=
    1. __init__.py 初始化logger
    import logging.config
    
    logging.config.fileConfig("logging.conf")
    logger = logging.getLogger(\__name__)
    logger.debug("started logging %s." % \__name__)
    1. .gitignore 在项目中排除log文件
    # project
    *.log

    config使用

    import ConfigParser
    
    config = ConfigParser.ConfigParser()
    config.read("d:/influence.conf")
    username = config.get("weibo", "username")
    password = config.get("weibo", "password")

    缓存的使用

    python3自带,python2下使用lru_cache_function

    import lru
    
    cookies = [000, 111, 222, 333, 444]
    
    
    @lru.lru_cache_function(max_size=1024, expiration=15 * 60)
    def f(account):
        print "Calling f(" + str(account) + ")"
        return cookies[account]
    
        print f(3)
        print f(0)
        print f(3)  # 15分钟内有效

    异常的使用

    import traceback
    
    try:
        raise IOError("io error!!!")  # 抛出第一个异常,被except捕获了    
    except IOError, io_error:
        traceback.print_exc()   # 打印异常栈,第一个异常的栈
        print sys.exc_info()    # 打印异常信息
        print io_error          # 打印异常消息
        pass  # 异常处理完毕,系统正常继续
    finally:
        print "1 print always..."
    
    try:
        raise IOError("io error!!!")  # 抛出第一个异常,被except捕获了
    except IOError, io_error:
        raise IOError("raise io error!!!")  # 抛出第二个异常,会被系统捕获,系统退出
    finally:
        print "2 print always..."  # 但是还是会运行这里

    注意:异常中不要使用裸露的except,except后跟具体的exceptions

    异常和日志的组合

    python编译时能检查的问题相对较少
    except 一定要打印 & 出WARN/ERROR的log

    语法杂项

    1.使用random choice随机选取seq一个值

    import random
    
    print random.choice((1, 2, 3))
    print random.choice(['3', '4', 12L])

    2.使用sum代替连加的reduce

    新建文件test_sum.py,使用py.test测试验证结果

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    
    
    def test_sum():
    assert sum([1, 2, 3], 0) == 6
    assert reduce(lambda a, b: a + b, [1, 2, 3], 0) == 6
    F:\gitlab\mola\house\learnpy>py.test
    ============================= test session starts =============================
    platform win32 -- Python 2.7.11, pytest-2.8.5, py-1.4.31, pluggy-0.3.1
    rootdir: F:\gitlab\mola\house\learnpy, inifile:
    collected 1 items
    
    test_sum.py .
    
    ========================== 1 passed in 0.01 seconds ===========================

    3.使用with处理文件连接(类似java7的自动关闭try)
    4.json编码存文件(注意两段的区别):

    person = {"name": "哈哈哈"}
    with open(file_name, "a") as f:
        f.write(json.dumps(person, ensure_ascii=False) + "\n")
    
    person = {"name": u"哈哈哈"}
    with codecs.open(file_name, "a", "utf-8") as f:
        f.write(json.dumps(person, ensure_ascii=False) + "\n")
    1. 使用startswith() and endswith()代替切片进行序列前缀或后缀的检查。比如:
      • Yes: if foo.startswith('bar'):优于
      • No: if foo[:3] == 'bar':
    2. 使用isinstance()比较对象的类型。比如
      Yes: if isinstance(obj, int): 优于
      No: if type(obj) is type(1):
    3. 判断序列空或不空,有如下规则
      Yes: if not seq:
      if seq:
      优于
      No: if len(seq)
      if not len(seq)
    4. 二进制数据判断使用 if boolvalue的方式。

    docstring

    模块/类/函数下的第一个字符串,作为文档存在
    可使用help()或者__doc__访问
    其间可以夹杂doctest作为简单的测试(较复杂的测试可以使用unittest或者功能强大但更简洁的py.test

    doctest

    新建hello_doctest.py,使用doctest验证其作用:

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    
    """
    This is the "example" module.
    
    The example module supplies one function, factorial().  For example,
    
    >>> factorial(5)
    120
    """
    
    
    def factorial(n):
    """Return the factorial of n, an exact integer >= 0.
    
        If the result is small enough to fit in an int, return an int.
        Else return a long.
    
        >>> [factorial(n) for n in range(6)]
        [1, 1, 2, 6, 24, 120]
        >>> [factorial(long(n)) for n in range(6)]
        [1, 1, 2, 6, 24, 120]
        >>> factorial(30)
        265252859812191058636308480000000L
        >>> factorial(30L)
        265252859812191058636308480000000L
        >>> factorial(-1)
        Traceback (most recent call last):
            ...
        ValueError: n must be >= 0
    
        Factorials of floats are OK, but the float must be an exact integer:
        >>> factorial(30.1)
        Traceback (most recent call last):
            ...
        ValueError: n must be exact integer
        >>> factorial(30.0)
        265252859812191058636308480000000L
    
        It must also not be ridiculously large:
        >>> factorial(1e100)
        Traceback (most recent call last):
            ...
        OverflowError: n too large
        """
    
    import math
    if not n >= 0:
    raise ValueError("n must be >= 0")
    if math.floor(n) != n:
    raise ValueError("n must be exact integer")
    if n + 1 == n:  # catch a value like 1e300
    raise OverflowError("n too large")
        result = 1
    factor = 2
    while factor <= n:
            result *= factor
            factor += 1
    return result
    
    
    if __name__ == "__main__":
    import doctest
        doctest.testmod()
    

    F:\gitlab\mola\house\learnpy>python hello_doctest.py -v

    Trying:
        factorial(5)
    Expecting:
        120
    ok
    Trying:
        [factorial(n) for n in range(6)]
    Expecting:
        [1, 1, 2, 6, 24, 120]
    ok
    Trying:
        [factorial(long(n)) for n in range(6)]
    Expecting:
        [1, 1, 2, 6, 24, 120]
    ok
    Trying:
        factorial(30)
    Expecting:
        265252859812191058636308480000000L
    ok
    Trying:
        factorial(30L)
    Expecting:
        265252859812191058636308480000000L
    ok
    Trying:
        factorial(-1)
    Expecting:
        Traceback (most recent call last):
            ...
        ValueError: n must be >= 0
    ok
    Trying:
        factorial(30.1)
    Expecting:
        Traceback (most recent call last):
            ...
        ValueError: n must be exact integer
    ok
    Trying:
        factorial(30.0)
    Expecting:
        265252859812191058636308480000000L
    ok
    Trying:
        factorial(1e100)
    Expecting:
        Traceback (most recent call last):
            ...
        OverflowError: n too large
    ok
    2 items passed all tests:
       1 tests in __main__
       8 tests in __main__.factorial
    9 tests in 2 items.
    9 passed and 0 failed.
    Test passed.

    注意:在测试通过的情况下,默认不打印详情。加上-v参数可以查看测试的详情。

    样式:PEP8

    PEP8全文见:https://www.python.org/dev/peps/pep-0008/

    自动检测: autopep8

    安装:pip install autopep8

    关键点如下:
    1. 模块内容的顺序
    模块说明和docstring—import—globals&constants—其他定义。其中import部分,又按标准、三方和自己编写顺序依次排放,之间空一行。

    1. 不要在一句import中多个库,比如import os, sys不推荐。

    2. 如果采用from XX import XX引用库,可以省略‘module.’,都是可能出现命名冲突,这时就要采用import XX。

    3. 模块命名尽量短小,使用全部小写的方式,可以使用下划线。

    4. 包命名尽量短小,使用全部小写的方式,不可以使用下划线。

    5. 类的命名使用CapWords的方式,模块内部使用的类采用_CapWords的方式。

    6. 异常命名使用CapWords+Error后缀的方式。

    7. 函数命名使用全部小写的方式,可以使用下划线。

    8. 常量命名使用全部大写的方式,可以使用下划线。

    9. 类的属性(方法和变量)命名使用全部小写的方式,可以使用下划线。
      类的属性有3种作用域public、non-public和subclass API,可以理解成C++中的public、private、protected,non-public属性前,前缀一条下划线。
      类的属性若与关键字名字冲突,后缀一下划线,尽量不要使用缩略等其他方式。

    11.其他:
    - 有语义分隔的加空行
    - 标点符号后加空格
    - 长行加\分行,运算符置于下行头部

    import this:Python 之禅

    • Beautiful is better than ugly.
      优美胜于丑陋。

    • Explicit is better than implicit.
      显式胜于隐式。

    • Simple is better than complex.
      简单胜于复杂。

    • Complex is better than complicated.
      复杂胜于难懂。

    • Flat is better than nested.
      扁平胜于嵌套。

    • Sparse is better than dense.
      分散胜于密集。

    • Readability counts.
      可读性应当被重视。

    • Special cases aren’t special enough to break the rules. Although practicality beats purity.
      尽管实用性会打败纯粹性,特例也不能凌驾于规则之上。

    • Errors should never pass silently. Unless explicitly silenced.
      除非明确地使其沉默,错误永远不应该默默地溜走。

    • In the face of ambiguity, refuse the temptation to guess.
      面对不明确的定义,拒绝猜测的诱惑。

    • There should be one– and preferably only one –obvious way to do it.
      用一种方法,最好只有一种方法来做一件事。

    • Although that way way not be obvious at first unless you’re Dutch.
      虽然一开始这种方法并不是显而易见的,但谁叫你不是Python之父呢。

    • Now is better than never. Although never is often better than right now.
      做比不做好,但立马去做有时还不如不做。

    • If the implementation is hard to explain, it’s a bad idea.
      如果实现很难说明,那它是个坏想法。

    • If the implementation is easy to explain, it may be a good idea.
      如果实现容易解释,那它有可能是个好想法。

    • Namespaces are one honking great idea – let’s do more of those!
      命名空间是个绝妙的想法,让我们多多地使用它们吧!


    版权声明:转载必须注明本文转自 East196 的博客:http://blog.csdn.net/east196

    展开全文
  • 网上收集的Goolge Python编码规范。包含两个版本,Google Python Style Guide中文版_li3p.pdf,Google-python-style-guide中文版_guoqiao.pdf。两份文档内容基本一致,guoqiao翻译的格式比较好,而且带详细书签。
  • 我的 Python 编码规范

    万次阅读 多人点赞 2018-12-11 16:35:19
    PEP是Python Enhancement Proposal(Python 增强建议书)的简写。PEP8整个文档引用了很多其他标准,看起来挺复杂的,我从来没有完整读下来过。好在龟叔说过,A Foolish Consistency is the Hobgoblin of Little ...

    1. 前言

    说起编码规范,很多文章都会提到PEP8这个规范。PEP是Python Enhancement Proposal(Python 增强建议书)的简写。PEP8整个文档引用了很多其他标准,看起来挺复杂的,我从来没有完整读下来过。好在龟叔说过,A Foolish Consistency is the Hobgoblin of Little Minds(尽信书,不如无书),只要保持一致性、可读性,就是一个好的规范。基于PEP8规范的原则,结合开发团队在工作中的养成的习惯,我整理了一份实用的编码规范,推荐给初学者。

    2. python 文件的组成

    为了便于描述,先上一个 demo,

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    
    
    """通常这里是关于本文档的说明(docstring),须以半角的句号、 问号或惊叹号结尾!
    
    本行之前应当空一行,继续完成关于本文档的说明
    如果文档说明可以在一行内结束,结尾的三个双引号不需要换行;否则,就要像下面这样
    """
    
    
    import os, time
    import datetime
    import math
    
    import numpy as np
    import xlrd, xlwt, xlutils
    
    import youth_mongodb
    import youth_curl
    
    
    BASE_PATH = r"d:\YouthGit"
    LOG_FILE = u"运行日志.txt"
    
    
    class GameRoom(object):
        """对局室"""
        
        def __init__(self, name, limit=100, **kwds):
            """构造函数!
            
            name        对局室名字
            limit       人数上限
            kwds        参数字典
            """
            
            pass
    
    
    def craete_and_start():
        """创建并启动对局室"""
        
        pass
    
    
    if __name__ == '__main__':
        # 开启游戏服务
        start()
    

    Linux 平台上,一个 python 源码文件应该以下部分组成。Windows 平台上,可以省略第一项。

    1. 解释器声明
    2. 编码格式声明
    3. 模块注释或文档字符串
    4. 模块导入
    5. 常量和全局变量声明
    6. 顶级定义(函数或类定义)
    7. 执行代码

    3. 编码格式声明

    通常,编码格式声明是必需的。如果 python 源码文件没有声明编码格式,python 解释器会默认使用 ASCII 编码,一旦源码文件包含非ASCII编码的字符,python 解释器就会报错。以 UTF-8 为例,以下两种编码格式声明都是合乎规则的。

    # -*- coding: utf-8 -*-
    
    # coding = utf-8
    

    我一直 UTF-8 编码格式,喜欢使用第一种声明方式。

    Windows 平台上,编码格式声明必须位于 python 文件的第一行。Linux 平台上,编码格式声明通常位于 python 文件的第二行,第一行是 python 解释器的路径声明。

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    

    4. 缩进

    统一使用 4 个空格进行缩进。绝对不要用tab, 也不要tab和空格混用。对于行连接的情况,我一般使用4空格的悬挂式缩进。例如:

    var_dict = {
        'name': 'xufive',
        'mail': 'xufive@sdysit.com'
    }       
    

    5. 引号

    引号使用的一般性原则:

    • 自然语言使用双引号
    • 机器标识使用单引号
    • 正则表达式使用双引号
    • 文档字符串 (docstring) 使用三个双引号

    6. 注释

    #号后空一格,段落件用空行分开(同样需要#号):

        # 块注释
        # 块注释
        #
        # 块注释
        # 块注释
    

    行内注释,至少使用两个空格和语句分开:

    age += 1  # 年龄增加一岁
    

    比较重要的注释段, 使用多个等号隔开, 可以更加醒目, 突出重要性:

        server= gogame(room, options)
        
        # =====================================
        # 请勿在此处倾倒垃圾!!!
        # =====================================
        
        if __name__ == '__main__':
            server.run()
    

    7. 空行

    空行使用的一般性原则:

    • 编码格式声明、模块导入、常量和全局变量声明、顶级定义和执行代码之间空两行
    • 顶级定义之间空两行,方法定义之间空一行
    • 在函数或方法内部,可以在必要的地方空一行以增强节奏感,但应避免连续空行

    8. 空格

    空格使用的一般性原则:

    • 在二元运算符两边各空一格,算术操作符两边的空格可灵活使用,但两侧务必要保持一致
    • 不要在逗号、分号、冒号前面加空格,但应该在它们后面加(除非在行尾)
    • 函数的参数列表中,逗号之后要有空格
    • 函数的参数列表中,默认值等号两边不要添加空格
    • 左括号之后,右括号之前不要加添加空格
    • 参数列表, 索引或切片的左括号前不应加空格

    9. 文档字符串

    文档字符串是包、模块、类或函数里的第一个语句。这些字符串可以通过对象的__doc__成员被自动提取,并且被pydoc所用。文档字符串的使用三重双引号(""")。如果文档字符串内容不能在一行内写完,首行须以句号、 问号或惊叹号结尾,接一空行,结束的三重双引号必须独占一行。

    10. 导入模块

    导入总应该放在文件顶部,位于模块注释和文档字符串之后,模块全局变量和常量之前。导入应该按照从最通用到最不通用的顺序分组,分组之间空一行:

    1. 标准库导入
    2. 第三方库导入
    3. 应用程序指定导入

    应当避免使用以下的导入方法:

    from math import *
    

    11. 命名规范

    命名建议遵循的一般性原则:

    • 模块尽量使用小写命名,首字母保持小写,尽量不要用下划线
    • 类名使用驼峰(CamelCase)命名风格,首字母大写,私有类可用一个下划线开头
    • 函数名一律小写,如有多个单词,用下划线隔开
    • 私有函数可用一个下划线开头
    • 变量名尽量小写, 如有多个单词,用下划线隔开
    • 常量采用全大写,如有多个单词,使用下划线隔开
    展开全文
  • Python编码问题

    千次阅读 2014-07-18 00:51:11
    Python编码问题详解 继上一篇文章字符集和编码详解总结了常见字符编码后,这篇文章会对python中常见的编码问题进行分析和总结。由于python3.x版本和python2.x版本在字符编码方面有很大差异,所以本文都是以Python...

    Python编码问题总结

    继上一篇文章字符集和编码详解总结了常见字符编码后,这篇文章会对python中常见的编码问题进行分析和总结。由于python3.x版本和python2.x版本在字符编码方面有很大差异,所以本文都是以Python2.7.5来分析2.x版本中的字符编码问题。


    1.Python编码基础

    1.1 str和unicode

    python中有两种数据模型来支持字符串这种数据类型,str和unicode,它们的基类都是basestring。比如s = "中文"就是str类型的字符串,而u=u"中文"就是一个unicode类型的字符串。unicode是由str类型的字符串解码后得到,unicode也可以编码成str类型。即

    str --> decode -->unicode
    unicode --> encode --> str

    严格来说,str也许应该叫做字节串,因为对于UTF-8编码的str类型"中文",使用len()函数得到的结果是6,因为UTF-8编码的str类型“中文”实际是"\xe4\xb8\xad\xe6\x96\x87"。而对于unicode类型u“中文”(实际是u"\u4e2d\u6587"),使用len()函数得到结果是2.

    1.2 头部编码声明

    在python源代码文件中如果有用到非ascii字符,比如中文,那么需要在源码文件头部声明源代码字符编码,格式如下:

    #-*- coding: utf-8 -*-

    这个格式看起比较复杂,其实python只检查#、coding,编码等字符串,可以简写成#coding:utf-8,甚至还可以写成#coding:u8。


    2.Python2.x常见编码问题

    2.1 头部编码声明和文件编码问题

    文件头部编码声明决定了python解析源码中的str的编码选择方式,比如头部声明的是utf-8编码,则代码中s="中文"python就会按照utf-8编码格式来解析,通过repr(s)可以看到字符编码是"\xe4\xb8\xad\xe6\x96\x87",如果头部声明的编码是gbk编码,则python会对s采用gbk编码解析,结果是"\xd6\xd0\xce\xc4"

    需要注意的是,文件本身的编码要跟文件头部声明编码一致,不然就会出现问题。文件本身的编码在Linux下面可以在vim下用命令set fenc来查看。如果文件本身编码是gbk,而源码文件头部声明的编码是utf-8,这样如果源码中有中文就会有问题了,因为本身中文str存储是按照gbk编码来的,而python在解析str的时候又以为是utf-8编码,这样就会报SyntaxError: (unicode error) 'utf8' codec can't decode byte错误。

    2.2 默认编码问题

    下面看个python默认编码导致的问题:

    #coding: utf-8
    u = u"中文"
    print repr(u) # u'\u4e2d\u6587'
    
    s = "中文"
    print repr(s) # '\xe4\xb8\xad\xe6\x96\x87'
    
    u2 = s.decode("utf-8")
    print repr(u2) # u'\u4e2d\u6587'
    
    #s2 = u.decode("utf-8") #编码错误
    #u2 = s.encode("utf-8") #解码错误
    

    注意实例中注释掉的2行代码,对于unicode最好不要直接调用decode,str最好不要直接调用encode方法。因为如果是直接调用,则相当于u.encode(default_encoding).decode("utf-8"),default_encoding是python的unicode实现中用的默认编码,即sys.getdefaultencoding()得到的编码,如果你没有设置过,那么默认编码就是ascii,如果你的unicode本身超出了ascii编码范围就会报错。同理,如果对str直接调用encode方法,那么默认会先对str进行解码,即s.decode(default_encoding).encode("utf-8"),如果str本身是中文,而default_encoding是ascii的话,解码就会出错,从而导致上面这两行会分别报UnicodeEncodeError: 'ascii' codec can't encode characters in position...错误和UnicodeDecodeError: 'ascii' codec can't decode byte 0xe4 in position...错误。

    上面例子中注释掉的两行代码如果执行就会报错,当然,如果本身str或者unicode都在ascii编码范围,就没有问题。比如s = "abc"; s.encode("utf-8")就不会有问题,语句执行后会返回一个跟s的id不同的str。

    那如果要解决实例1中的问题,有两种方法,其一是明确指定编码,如下所示:

    #coding: utf-8
    u = u"中文"
    print repr(u) # u'\u4e2d\u6587'
    
    s = "中文"
    print repr(s) # '\xe4\xb8\xad\xe6\x96\x87'
    
    u2 = s.decode("utf-8")
    print repr(u2) # u'\u4e2d\u6587'
    
    s2 = u.encode("utf-8").decode("utf-8")  # OK                                    
    u2 = s.decode("utf8").encode("utf-8")   # OK
    

    第二种方法就是更改python的默认编码为文件编码格式,如下所示(这里只所以要reload sys模块,是因为python初始化后删除了setdefaultencoding方法):
    #coding:utf-8                                                                   
    
    import sys 
    reload(sys)
    sys.setdefaultencoding("utf-8") #更改默认编码为utf-8
    
    u = u"中文"
    print repr(u) # u'\u4e2d\u6587'
    
    s = "中文"
    print repr(s) # '\xe4\xb8\xad\xe6\x96\x87'
    
    u2 = s.decode("utf-8")
    print repr(u2) # u'\u4e2d\u6587'
    
    s2 = u.decode("utf-8")
    u2 = s.encode("utf-8")

    2.3读写文件编码

    采用python的open()方法打开文件时,read()读取的是str,编码就是文件本身的编码。而调用write()写文件时,如果参数是unicode,则需要用指定编码encode,如果write()参数是unicode而且没有指定编码,则会采用python默认编码encode后再写入。

    #coding:utf-8                                                                   
    f = open("testfile")
    s = f.read()
    f.close()
    print type(s) # <type 'str'>
    
    u = s.decode("utf-8") #testfile是utf-8编码
    f = open("testfile", "w")
    f.write(u.encode("gbk")) #以gbk编码写入,testfile为gbk编码
    f.close()

    此外,python的codecs模块提供了一个open()方法,可以指定编码打开文件,使用这个方法打开文件读取返回是unicode。写入时,如果write参数是unicode,则使用打开文件时的编码写入,如果是str,则先使用默认编码解码成unicode后再以打开文件的编码写入(这里需要注意如果str是中文,而默认编码sys.getdefaultencoding()是ascii的话会报解码错误)。

    #coding:gbk
    import codecs
    
    f = codecs.open('testfile', encoding='utf-8')
    u = f.read()
    f.close()
    print type(u) # <type 'unicode'>
    
    f = codecs.open('testfile', 'a', encoding='utf-8')
    f.write(u) #写入unicode
    
    # 写入gbk编码的str,自动进行解码编码操作
    s = '汉'
    print repr(s) # '\xba\xba'
    # 这里会先将GBK编码的str解码为unicode再编码为UTF-8写入
    #f.write(s) #默认编码为ascii时,这会报解码错误。
    f.close()


    3.参考资料

    展开全文
  • python编码转换

    千次阅读 2012-08-28 10:16:05
    python 编码转换 主要介绍了python编码机制,unicode, utf-8, utf-16, GBK, GB2312,ISO-8859-1 等编码之间的转换。 常见的编码转换分为以下几种情况: 自动识别 字符串编码 可以使用 chardet 模块自动...
  • Python 编码转换与中文处理

    千次阅读 2019-08-26 20:24:31
    Python 编码转换与中文处理 python 中的 unicode是让人很困惑、比较难以理解的问题. utf-8是unicode的一种实现方式,unicode、gbk、gb2312是编码字符集. decode是将普通字符串按照参数中的编码格式进行解析,然后...
  • python编码问题

    万次阅读 2019-06-28 10:59:33
    原来编码问题也这么有学问的,原来都是一通瞎试猜编码,现在可以参考下此图了
  • python 编码转换

    千次阅读 2011-04-20 10:31:00
    ====== python 编码转换 ====== <br />主要介绍了python编码机制,unicode, utf-8, utf-16, GBK, GB2312,ISO-8859-1 等编码之间的转换。 <br />**常见的编码转换分为以下几种情况:** <br...
  • Python 编码规范(Google) _ 菜鸟教程》
  • Python编码问题的解决方案总结

    千次阅读 2018-12-10 16:20:18
    Python编码问题的解决方案总结 初学 Python,相信大家遇到的一大难题就是编码问题,如下: &gt;&gt;&gt; Traceback (most recent call last): File "/Users/FishC/Documents/Python/test.py&...
  • Windows下python编码如何实现监控某个进程网络流量
  • Python 编码问题整理

    千次阅读 2011-10-14 10:10:43
    Python 的过程中遇到编码出错的问题。在这里讨论一下,以后整理一下留作参考。 先说说我目前对 Python 编码的理解: 几个概念性的东西 ANSCII: 标准的 ANSCII 编码只使用7个比特来表示一个字符
  • Python编码异常处理

    万次阅读 2017-08-03 10:21:21
    TypeError: not a valid non-...1:python爬虫时的参数(字符串),编码异常解决 2:>>>data = urllib.parse.urlencode(values)(重点:python3.0后的编码器urlencode更新后改为quote_plus) 3:TypeError: not a va
  • pep8 python编码规范中文版

    千次阅读 2014-08-27 14:21:12
    PEP: 8 标题: Python编码建议 版本: 2132f8d8bcb4 最后更新: 2014-08-17 12:24:10 -0400 (Sun, 17 Aug 2014) 作者: Guido van Rossum , Barry Warsaw , Nick Coghla
  • PYTHON编码和解码

    千次阅读 2018-10-21 14:04:40
    从第一天接触Python就对解码和编码的问题很困惑,最近在学习网络数据爬虫,又遇到了一系列的解码和编码问题,处理中文编码问题真的好麻烦,这次真的需要好好填坑了。 详细内容下面的文章: Python字符串的编码与解码...
  • PEP8 Python 编码规范整理

    千次阅读 2015-06-01 11:17:27
    决定开始Python之路了,利用业余时间,争取更深入学习Python。编程语言不是艺术,而是工作或者说是工具,所以整理并遵循一套编码规范是十分...PEP8 Python 编码规范 一 代码编排 1 缩进。4个空格的缩进(编辑器
  • python编码笔记

    千次阅读 2015-07-26 15:49:56
    编码是最痛苦的事情,python的decode 好像原意是decode ToUnicodeFormat from original Format ,也就是说decode的作用是将str对象变成unicode对象,原来的str是original Format 编码。这人写的不错,有时间读读 ...
  • python 编码转换

    千次阅读 2019-04-08 14:52:26
    一、了解字符编码的知识储备  1. 文本编辑器存取文件的原理(nodepad++,pycharm,word)  打开编辑器就打开了启动了一个进程,是在内存中的,所以在编辑器编写的内容也都是存放与内存中的,断电后数据丢失,...
  • selenium+python编码

    千次阅读 2017-01-23 14:50:46
    中文报错:#coding=utf-8 ...运行时就报编码错误,这个时候我们可以在脚本开头声明编码为 utf-8,然后在中文字符的前面加个小u 就解决了(表示转成 python Unicode 编码): 如果uft-8不能解决问题,就写上g
  • 修改python编码格式

    千次阅读 2016-11-30 13:53:21
    Python在安装时,默认的编码是ascii,当程序中出现非ascii编码时,python的处理常常会报这样的错UnicodeDecodeError: 'ascii' codec can't decode byte 0x?? in position 1: ordinal not in range(128),python没...
  • python编码错误:UincodeDecodeError
  • 摘取了对自己有用的片段,并进行格式整理文件的编码格式和编码声明的作用文件编码格式 源文件的编码格式对字符串的声明有什么作用呢? 文件的编码格式决定了在该源文件中声明的字符串的编码格式。例如: str = ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 393,813
精华内容 157,525
关键字:

python编码

python 订阅