精华内容
下载资源
问答
  • python实践指南 这份 主要是自我见解 的指南旨在为Python初学者和专家提供一个 关于Python安装、配置、和日常使用的最佳实践手册。
  • python最佳实践

    2018-08-21 14:28:23
    这段时间开始研究Python了在日常工作中总结了以下的实践: if retrun while 中不用使用()(括号) 运算中使用() (1<<2)&5 设置整数型浮点使用 7.0 方法名小写,类名首字母大写 ...

    这段时间开始研究Python了在日常工作中总结了以下的实践:
    if retrun while 中不用使用()(括号)
    运算中使用()

    (1<<2)&5

    设置整数型浮点使用

    7.0

    方法名小写,类名首字母大写
    def funciton:
    class Function:

    别使用build-in的关键字 例如不要使用
    list=[1,2,3] dict={'name':'xiaoli'}
    使用in keys()

    if x in dict.keys():

    通常不要使用可变量作为默认值可以使用一下方式
    使用 is 判断None

    def test(x,de_x=None):
        if de_x is None:
            de_x=[]

    可以的话尽量使用迭代方法:

    for key, val in mapping.iteritems(): ...

    性能分析:

    python -m profile -o stats myscript.py
    
    import pstats
    p = pstats.Stats('stats')
    p.sort_stats('time').print_stats(15) #按执行时长排序

    转换编码

    -*- coding: UTF-8 -*-
    #循环
    while True
        xxx
        if yyy: break
    #交换
    a=5
    b=3
    a,b=b,a
    #同一赋值
    
    #bad
    a=5
    b=5
    c=5
    #good
    a=b=c=5
    
    if x == 1: y = fun1(x)
    elif x == 2: y = fun2(x)
    elif x == 3: y = fun3(x)
    else: y = None 
    #可以使用字典形式的方法:
    funs = {1: fun1, 2: fun2, 3: fun3}
    y = funs.get(x, lambda x:None)(x)
    
    #拼接字符串
    sl = ["ab", "cd", "ef"]
    all = "".join(sl)
    
    #使用列表推导式
    vals = [2, 3, -5, 0]
    result = [el * el for el in vals if el > 0]
    
    #私有变量用_标注 
    class Foo(object):
        def __init__(self, x, y, z):
            self.x_public = x
            self._y_private = y
            self.__z_veryprivate = z
    print (Foo(1, 2, 3).x_public)
    
    #从-2开始叠加
    vals = [5, 7 ,8]
    tot = sum(vals, -2.0) #tot=18
    
    #反转list等
    alist[::-1]
    
    
    #判别类型
    if isinstance(s, basestring): ...
    if isinstance(seq, (list, tuple)): ...
    if hasattr(seq, "__getitem__"): ...
    
    #使用d=dict()会去先load dict()方法
    d=[]
    d={} 
    
    # return a.sort() 会先去load() sort()方法
    a.sort()
    retrun a 
    
    #不用a<b<c<d
    a<b and b<c and c<d 
    
    #不用 a!=2 不用a is not 2
    if not a is 2:
    
    #不用if not a 不用if len(a) 拒绝 if a==[] (when a is list)
    if a
    
    #不用 if a is None /if a is not None (a是对象时)
    if not a
    
    #不用for i in range(len(list)) 
    for x,y in enumerate(list) 
    
    #不用return str((a*(b+c)))
    return "%s" % (a*(b+c))  
    
    #不用return sum(i for i in range(50000))
    for i in range(50000):
            s += i
        return s
    
    #不用for i in range(1000):
    #        l.append(i)
    #    return l
    return [i for i in range(1000)]
    
    
    展开全文
  • 本书从数据分析、web开发和科学软件开发方面介绍了专业人员如何运用Python进行实践操作,提升技巧必备
  • 高清版,Python最佳实践指南-The Hitchiker's Guide to Python
  • Python最佳实践指南(彩色阅读版)
  • Hitchhiker的Python指南Python最佳实践指南→在以下位置阅读免费指南:docs.python-guide.org进行中。 如果您想提供帮助,请这样做。 有很多工作要做。 该指南目前是und Hitchhiker的Python指南Python最佳实践指南→...
  • 这份主要是自我见解的指南旨在为Python初学者和 专家提供一个关于Python安装、配置、和日常使用的最佳实践手册。
  • 昨天推送了一篇《来自...本系列打算聚焦Python领域的书籍,初期选书的标准主要有两条:一是要有中文版,二是要有免费开源的在线资源,原因很简单,技术书籍由于其特殊性,在线阅读的体验是最佳的,不管是排版、...

    昨天推送了一篇《来自Kenneth Reitz大神的建议:避免不必要的面向对象编程》,文中K神的建议出自他发起和维护的开源项目,这也就是我们今天荐书的主角了。

    在介绍今天的书目之前,我想先跟大家介绍一下这个荐书系列。本系列打算聚焦Python领域的书籍,初期选书的标准主要有两条:一是要有中文版,二是要有免费开源的在线资源,原因很简单,技术书籍由于其特殊性,在线阅读的体验是最佳的,不管是排版、获取源码、摘录笔记还是分享交流,都是最有效果的。至于更新的频率,不会很频繁,预计两周左右推一次。如果你有什么需求或者建议,欢迎到后台给我留言。

    下面请出今天主角《Python最佳实践指南》。

    这本书的英文名是《The Hitchhiker's Guide to Python》,hitchhiker直译是搭便车的旅行者。你也许看过一部著名的科幻电影(或原著)《银河系漫游指南》,它的英文名是《The Hitchhiker's Guide to the Galaxy》。这本书也许就是在致敬这部电影(或原著)吧。

    书的第一作者是圈内大牛Kenneth Reitz,他最为人知的贡献是requests库,我们尊称一句“K神”。他在2011年发起了一个开源项目,也就是这本书的在线版本,Python社区内积极响应,截止现在有346位提交贡献者,github上收获star数15754个,可谓十分受欢迎了。

    2016年,O'Reilly出版社终于出手了,所以就有了这本书的英文版。我们国内开发者的热情也很高,现在网上就流传了不少译本,文末附了两个在线阅读地址,我主要推荐大家阅读的就是这两个版本。特别是第一个版本,因为翻译得更到位,阅读更友好,而网站做的也挺不错。(PS:为了方便小伙伴们学习,我也找到了电子书,关注公众号Python猫,后台发送“爱学习”,可获得下载链接。)

    由于文化差异,这本书名若直译过来肯定不恰当,若像电影那般译作《Python世界漫游指南》,似乎还挺有意思的。不过,这两个中文译本都译作了《Python最佳实践指南》。

    书的内容比较零散,涉及从环境搭建、编辑器选择、代码风格、Web应用,再到机器学习、与C/C++库交互等等内容。

    在“有什么”方面,书中列了很多,在“怎么做”方面,书中其实讲的并不多,很多时候,作者只是给了链接,他希望读者根据指引,自己去完成那些部分的学习。

    从这点来看,一方面,这本书确实不适合初学者用来入门,另一方面,它适合有基础的人来阅读,矫正一些错误的认知,获得一些实践的套路。

    在准备材料的时候,我发现这本书刚在上个月出了中文纸质书,这还真是巧合!(题外话:下一期荐书估计很快会推出,说起来也有一个巧合。至于是啥,先保密。)

    纸书的译者和出版社也许为了销量考虑,在书名上又加了四个字,最后纸书的书名成了《Python编程之美:最佳实践指南》。

    照例先看看豆瓣情况:

    今年9月出版,真是新鲜出炉。评价人数太少,现在还没有分数。标记想读和在读的人数也极少,大概知道这本书的人不算多吧。

    这期荐书,大概率是最早的荐书文章之一了。而读者们,你们也是最早知道这本书的人们(之一)了。(PS:出版社同仁,麻烦后台联系我支付推广报酬)

    本书的译者夏永锋/廖邦杰与requests挺有缘,据夏在译者序中说:

    因为对“for humans”理念的认同,也因为我经常使用Requests,所以当Reitz 在GitHub上邀请我翻译Requests 文档中文版时,我欣然接受,和本书的另一位译者邦杰共同翻译了Requests 文档的首个官方中文版。

    因为这两人,我们有理由相信书籍的内容质量以及翻译水准。

    这本纸质书还有一个很值一读的原因:书中有Requests 、Werkzeug 、Flask 等5个知名开源项目的源码阅读内容,并介绍如何通过阅读源码来提升编程技术水平。这些内容,中英文的开源版本都还没有,所以让人挺期待的。

    相关链接:

    The Hitchhiker's Guide to Python:
    https://docs.python-guide.org/

    Python最佳实践指南(中文):
    https://pythoncaff.com/docs/python-guide/2018
    https://pythonguidecn.readthedocs.io/zh/latest/

    github(英-中):
    https://github.com/realpython/python-guide
    https://github.com/Prodesire/Python-Guide-CN

    豆瓣条目:

    https://book.douban.com/subject/30314669/

    展开全文
  • 30个Python最佳实践和技巧,你值得拥有~

    千次阅读 多人点赞 2020-02-03 12:00:00
    全文共8869字,预计学习时长26分钟来源:Pexels1.使用Python3温馨提示:官方宣布自2020年1月一日起将不再支持Python2。这份指南里的大多数例子也只在Pyth...


    全文共8869字,预计学习时长26分钟

    来源:Pexels 

    1. 使用Python3

     

    温馨提示:官方宣布自2020年1月一日起将不再支持Python2。这份指南里的大多数例子也只在Python3中适用。如果您还在使用Python2.7,赶快更新吧。如果您使用的是苹果电脑,可以使用Homebrew轻松升级。

     

    2. 检查Python的最低要求版本

     

    您可以直接使用代码来查看Python版本,确保将来不会出现脚本和Python版本不兼容的情况发生。请看示例:

     

    ifnot  sys.version_info > (2, 7):
       # berate your user for running a  10 year
       # python version
    elifnot  sys.version_info >= (3, 5):
       # Kindly tell your user (s)he  needs to upgrade
       # because you're using 3.5  features
    


     viewrawcheck_python_version.py hosted with ❤ by GitHub

    3. 使用IPython

     

    作者截图

     

    实际上,IPython是一个增强的shell。自动完成功能已足以令人惊叹,但它还有更多功能。我非常喜欢内置的魔术命令。以下是一些例子:

     

    ·       %cd -用于更改当前工作目录

    ·       编辑-打开编辑器,并执行您在关闭编辑器后键入的代码

    ·       %env — 展示当前环境变量

    ·       %pip install [pkgs] — 在交互环境下安装包

    ·       %time 和 %timeit — 计算Python代码的执行时间

     

    另一个有用的功能是引用前一个命令的输出。In和Out是实际的对象。您可以通过使用Out[3]来进行第三个命令的输出。

     

    下载Python命令安装Ipython:

     

    pip3install ipython
    

     

    4. 列表推导

     

    列表推导可以替换丑陋的用于填充列表的for循环。列表推导的基本语法是:

     

    [expression for item in list if conditional ]
    

     

    这是一个最基本的例子,使用数字序列填充列表:

     

    mylist = [i for i inrange(10)]
    print(mylist)
    # [0, 1,  2, 3, 4, 5, 6, 7, 8, 9]
    


     viewrawlist_comprehensions_1.py hostedwith ❤ by GitHub

    同时你还可以用这种表达进行数学运算:

     

    squares = [x**2for x inrange(10)]
    print(squares)
    # [0, 1,  4, 9, 16, 25, 36, 49, 64, 81]
    


     viewrawlist_comprehensions_2.py hostedwith ❤ by GitHub

    甚至额外创建一个新函数:

     

    defsome_function(a):
        return (a +5) /2
    my_formula  = [some_function(i) for i inrange(10)]
    print(my_formula)
    # [2, 3,  3, 4, 4, 5, 5, 6, 6, 7]
    

     viewrawlist_comprehensions_3.py hostedwith ❤ by GitHub

    最终,你可以使用“if”来过滤列表。在这个例子中,只保留了能被2整除的值

     

    filtered  = [i for i inrange(20) if i%2==0]
    print(filtered)
    # [0, 2,  4, 6, 8, 10, 12, 14, 16, 18]
    


     viewrawlist_comprehensions_4.py hosted with ❤ by GitHub

    5.检查对象的内存使用

     

    使用 sys.getsizeof(),可以检查对象的记忆内存:

     

    import sys
    mylist =range(0, 10000)
    print(sys.getsizeof(mylist))
    # 48
    


     viewrawcheck_memory_usage_1.py hostedwith ❤ by GitHub

    为什么这样一个巨大的列表仅占48字节内存?

     

    这是因为range函数返回的类只表现为一个列表。范围比使用实际的数字列表更节省内存。

     

    你可以自己使用列表推导创建同一范围内的实际数字列表:

     

    import sys
    myreallist  = [x for x inrange(0, 10000)]
    print(sys.getsizeof(myreallist))
    # 87632
    


     viewrawcheck_memory_usage_2.py hosted with ❤ by GitHub

    6. 返回多个值

     

    来源:Pexels

    Python中的函数可以返回多个变量,而无需字典、列表或类。它的工作原理如下:

     

    defget_user(id):
        # fetch user from database
        # ....
        return name,  birthdate
    name,  birthdate = get_user(4)
    


     viewrawreturn_multiple_variables.py hosted with ❤ by GitHub

    对于有限数量的返回值,这是可以的。但是任何超过3个值的内容都应该放到一个(data)类中。

     

    7. 使用数据类

     

    从3.7版开始,Python提供了数据类。与常规类或其他替代方法(如返回多个值或字典)相比,有几个优点:

     

    ·  一个数据类需要最少的代码

    ·  可以比较数据类,因为已经实现了_eq__

    ·  您以轻易打印一个数据类进行调试,因为也实现了_repr__

    ·  数据类需要类型提示,减少了出错几率

     

    下面是一个数据类的例子:

     

    from  dataclasses import dataclass
    @dataclass
    classCard:
        rank: str
        suit: str
    card = Card("Q", "hearts")
    print(card == card)
    # True
    print(card.rank)
    # 'Q'
    print(card)
    Card(rank='Q', suit='hearts'
    


     viewrawdataclass.py hosted with ❤ by GitHub

    点击这里查看高阶指南 。

     

    8. 变量交换

     

    一个小技巧就可以省略数行代码。

    a =1
    b =2
    a, b = b, a
    print (a)
    # 2
    print (b)
    # 1
    


     viewrawin_place_variable_swapping.py hosted with ❤ by GitHub

    9. 合并字典(Python3.5+)

     

    自Python3.5 以来,合并字典更为简便

     

    dict1 = { 'a': 1, 'b': 2 }
    dict2 = { 'b': 3, 'c': 4 }
    merged = { **dict1, **dict2 }
    print  (merged)
    # {'a':  1, 'b': 3, 'c': 4}
    


     viewrawmerging_dicts.py hostedwith ❤ by GitHub

    如果有重叠的值,来自第一个字典的值将被覆盖。

     

    10. 标题大小写

     

    这只是其中一种有趣的玩法:

    mystring  ="10  awesome python tricks"
    print(mystring.title())
    '10  Awesome Python Tricks'
    

     viewrawstring_to_titlecase.py hosted with ❤ by GitHub

    11. 切割字符串至列表

     

    来源:Pexels

    可以将字符串拆分为字符串列表。在下例中,根据空格切割

     

    mystring  ="The  quick brown fox"
    mylist =  mystring.split(' ')
    print(mylist)
    #  ['The', 'quick', 'brown', 'fox']
    


     viewrawstring_to_list.py hosted with ❤ by GitHub

    12. 从字符串列表中创建一个字符串

     

    与上一个技巧正好相反,在本例中,从字符串列表中创建一个字符串,并在单词间输入空格:

    mylist = ['The', 'quick', 'brown', 'fox']
    mystring  ="  ".join(mylist)
    print(mystring)
    # 'The  quick brown fox'
    

     viewrawlist_to_string.py hostedwith ❤ by GitHub

    你或许在想为什么不用mylist.join(" ") ,好问题!

     

    归根结底,String.join()函数不仅可以连接列表,还可以连接任何可迭代的列表。将它放在String中会阻止在多个位置实现相同的功能。

     

    13. 表情

     

    表情要么是欢喜,要么是讨厌,这依表情而定。更重要的是,这在分析社交媒体数据时尤其有用。

     

    首先,下载表情模块

     

    pip3install emoji
    

     

    下载完之后,就可以按如下操作:

     

    import emoji
    result =  emoji.emojize('Python is :thumbs_up:')
    print(result)
    #  'Python is ????'
    # You  can also reverse this:
    result =  emoji.demojize('Python is ????')
    print(result)
    #  'Python is :thumbs_up:'
    


     viewrawemoji.py hosted with ❤ by GitHub

    访问表情包页面查看更多描述和示例

     

    14. 制作列表切片

     

    列表切片的句法:

     

    a[start:stop:step]
    

     

    Start, stop 和 step 都是可选项. 如果未设置,默认值会是

     

    ·       Start值为0

    ·       End为字符串末尾

    ·       step值为1

     

    以下是一个例子:

     

    # We can  easily create a new list from
    # the  first two elements of a list:
    first_two  = [1, 2, 3, 4, 5][0:2]
    print(first_two)
    # [1, 2]
    # And if  we use a step value of 2,
    # we can  skip over every second number
    # like  this:
    steps = [1, 2, 3, 4, 5][0:5:2]
    print(steps)
    # [1, 3,  5]
    # This  works on strings too. In Python,
    # you  can treat a string like a list of
    #  letters:
    mystring  ="abcdefdn  nimt"[::2]
    print(mystring)
    # 'aced  it'
    


     viewrawlist_slicing.py hosted with ❤ by GitHub

    15. 反转字符串和列表

     

    使用上面的切片符号来反转字符串或列表。通过使用负的步进值-1,从而反转元素:

     

    revstring  ="abcdefg"[::-1]
    print(revstring)
    #  'gfedcba'
    revarray  = [1, 2, 3, 4, 5][::-1]
    print(revarray)
    # [5, 4,  3, 2, 1]
    

     viewrawreversing_stuff.py hosted with ❤ by GitHub

    16. 展示小猫

     

    首先,安装Pillow(Python图像库的一个分支):

     

    pip3install Pillow
    

    下载这张图片,并把它命名为kittens.jpg:

    图源 TheDigitalArtist  Pixabay

     

    可以使用以下代码来显示Python代码中的图像:

     

    或者直接使用IPython:

     

    fromPILimport Image
    im =  Image.open("kittens.jpg")
    im.show()
    print(im.format,  im.size, im.mode)
    # JPEG  (1920, 1357) RGB
    


     viewrawpillow.py hosted with ❤ by GitHub

     

    除了显示图像,Pillow还可以分析、调整大小、过滤、增强、变形等等。有关它的所有特性,请参阅文档。

     

    17. 使用map()

     

    Python的一个内置函数是map()。map()的语法是: map(function, something_iterable)

     

    给定一个要执行的函数,和一些要运行的变量。它可以是任何可迭代的元素。在下面的例子中,我将使用一个列表。

     

    defupper(s):
        return  s.upper()
    mylist =list(map(upper,  ['sentence', 'fragment']))
    print(mylist)
    #  ['SENTENCE', 'FRAGMENT']
    #  Convert a string representation of
    # a  number into a list of ints.
    list_of_ints  =list(map(int, "1234567")))
    print(list_of_ints)
    # [1, 2,  3, 4, 5, 6, 7]
    


     viewrawmap.py hostedwith ❤ by GitHub

    看看自己的代码,看看是否可以在某处使用map()而不是循环!

     

    18. 从列表和字符串中提取独特元素

     

    通过使用set()函数创建一个集合,可以从一个列表或类似列表的对象中获得所有独特的元素:

     

    mylist = [1, 1, 2, 3, 4, 5, 5, 5, 6, 6]
    print (set(mylist))
    # {1, 2,  3, 4, 5, 6}
    # And  since a string can be treated like a
    # list  of letters, you can also get the
    # unique  letters from a string this way:
    print (set("aaabbbcccdddeeefff"))
    # {'a',  'b', 'c', 'd', 'e', 'f'}
    


     viewrawset.py hosted with ❤ by GitHub

    19. 找到频率出现最高的值

     

    查找列表或字符串中最常出现的值:

    test = [1, 2, 3, 4, 2, 2, 3, 1, 4, 4, 4]
    print(max(set(test), key=  test.count))
    # 4
    

     viewrawmost_frequent.py hostedwith ❤ by GitHub

    你明白为什么会这样吗?在继续阅读之前,试着自己找出答案。还没尝试吗?我要告诉你答案了。

     

    ·        max()将返回列表中的最大值。key参数接受单个参数函数来定制排序顺序,在本例中,它是test.count。该函数应用于iterable上的每个项目。

    ·       测试。count是一个内置的列表函数。它接受一个参数,并将计算该参数的出现次数。因此test.count(1)将返回2,而test.count(4)将返回4。

    ·        set(test)返回test中所有的唯一值,因此{1,2,3,4}

     

    因此,我们在这一行代码中所做的就是获取test的所有唯一值,即{1,2,3,4}。接下来,max将应用list.count 函数,并返回最大值。

     

    20. 创建一个进度条

     

    创建自己的进度条,这很有趣。但是使用进度包更快:

     

    pip3install progress
    

     

    现在可以花费更少的时间创建进度条

     

    from  progress.bar import Bar
    bar = Bar('Processing', max=20)
    for i inrange(20):
        # Do some work
        bar.next()
    bar.finish()
    


     viewrawprogress_bar.py hostedwith ❤ by GitHub

     

    21. 在交互式窗口中使用_

     

    来源:Pexels

    可以用下划线运算符得到最后一个表达式的结果,例如,在IPython中,如下所示:

     

    In [1]:3 * 3Out[1]: 9In [2]: _ + 3Out[2]: 12
    

     

    这也适用于Pythonshell。此外,IPython shell允许使用Out[n]来获取[n]中的表达式的值。例如,Out[1]会给出数字9。

     

    22. 快速创建一个web服务器

     

    快速启动web服务器,提供当前目录的内容:

     

    python3-m http.server
    

    如果您想与同事共享一些内容,或者想测试一个简单的HTML站点,这是非常有用的。

     

    23. 多行字符串

     

    尽管可以在代码中使用三引号将多行字符串包括在内,但这并不理想。放在三引号之间的所有内容都将成为字符串,包括格式,如下所示。


    我更喜欢第二种方法,该方法将多行连接在一起,使您可以很好地格式化代码。唯一的缺点是您需要显式添加换行符。

     

    s1 ="""Multi  line strings can be put
            between triple quotes. It's not ideal
            when formatting your code  though"""
    print (s1)
    # Multi  line strings can be put
    #         between triple quotes. It's not  ideal
    #         when formatting your code though
    s2 = ("You  can also concatenate multiple\n"+
            "strings  this way, but you'll have to\n"
            "explicitly  put in the newlines")
    print(s2)
    # You  can also concatenate multiple
    #  strings this way, but you'll have to
    #  explicitly put in the newlines
    

     viewrawmultiline_strings.py hosted with ❤ by GitHub

    24.三元运算符,用于条件赋值

     

    这是使代码兼具简洁性与可读性的另一种方法:[on_true] if [expression] else[on_false]

     

    例子:

     

    x = "Success!" if (y== 2) else "Failed!"
    

     

    25. 计算频率

     

    使用集合库中的Counter来获取包含列表中所有唯一元素计数的字典:

     

    from  collections import Counter
    mylist = [1, 1, 2, 3, 4, 5, 5, 5, 6, 6]
    c =  Counter(mylist)
    print(c)
    #  Counter({1: 2, 2: 1, 3: 1, 4: 1, 5: 3, 6: 2})
    # And it  works on strings too:
    print(Counter("aaaaabbbbbccccc"))
    #  Counter({'a': 5, 'b': 5, 'c': 5})
    


     viewrawcounter.py hosted with ❤ by GitHub

    26. 链接比较运算符

     

    在Python中链接比较运算符,以创建更易读和简洁的代码:

     

    x =10
    #  Instead of:
    if x >5and x <15:
        print("Yes")
    # yes
    # You  can also write:
    if5< x <15:
        print("Yes")
    # Yes
    

     viewrawchaining_comparisons.py hosted with ❤ by GitHub

    27. 添加一些颜色

     

     

    截图 Jonathan Hartley 源Colorama

     

    使用Colorama,在终端添加点颜色.

     

    from  colorama import Fore, Back, Style
    print(Fore.RED+'some  red text')
    print(Back.GREEN+'and  with a green background')
    print(Style.DIM+'and in  dim text')
    print(Style.RESET_ALL)
    print('back to  normal now')
    


     viewrawcolorama.py hosted with ❤ by GitHub

    28. 添加日期

     

    python-dateutil模块提供了对标准datetime模块的强大扩展。 通过以下方式安装:

    pip3 install python-dateutil
    

     

    您可以使用此库做很多很棒的事情。我只会重点介绍对我来说特别有用的例子:如模糊分析日志文件中的日期等。

     

    from  dateutil.parser import parse
    logline ='INFO  2020-01-01T00:00:01 Happy new year, human.'
    timestamp  = parse(log_line, fuzzy=True)
    print(timestamp)
    #  2020-01-01 00:00:01
    


     viewrawdateutil.py hosted with ❤ by GitHub

    只需记住:常规的Python日期时间功能不奏效时,python-dateutil就派上用场了!

     

    29. 整数除法

     

    在Python 2中,除法运算符(/)默认为整数除法,除非操作数之一是浮点数。因此,有以下操作:

     

    # Python 25 / 2 = 25 / 2.0 = 2.5
    

    在Python 3中,除法运算符默认为浮点除法,并且//运算符已成为整数除法。这样我们得到:

    Python 35 / 2 = 2.55 // 2 = 2
    

     

    30. 使用chardet进行字符集检测

     

    来源:Pexels

    使用chardet模块来检测文件的字符集。在分析大量随机文本时,这很有用。

     

    安装方式:

     

    pip install chardet
    

     

    现在,有了一个名为chardetect的额外命令行工具,可以像这样使用:

     

    chardetect somefile.txtsomefile.txt: ascii with confidence 1.0
    

    以上就是2020年30条最佳的代码技巧。我希望您能像享受创建列表一样,享受这些内容。如果您有任何意见,请随时发表评论!

     

    来源:Pexels


    推荐阅读专题

    留言点赞发个朋友圈

    我们一起分享AI学习与发展的干货

    编译组:李韵帷、吴亚芳

    相关链接:

    https://towardsdatascience.com/30-python-best-practices-tips-and-tricks-caefb9f8c5f5

    如转载,请后台留言,遵守转载规范

    推荐文章阅读

    ACL2018论文集50篇解读

    EMNLP2017论文集28篇论文解读

    2018年AI三大顶会中国学术成果全链接

    ACL2017论文集:34篇解读干货全在这里

    10篇AAAI2017经典论文回顾

    长按识别二维码可添加关注

    读芯君爱你

    展开全文
  • 用于python最佳实践和鲜为人知的技巧的整理/重构库 该工具尝试通过使用您可能不知道的语言功能和标准库功能,找到可能使更多的Python代码,更漂亮的代码位 例如直接嵌套的循环(嵌套为) for i in seq_a : for j...
  • 1.Python的作用域规则是,变量的创建总会创建一个新的local变量,但是变量的访问(包括修改)会先查找local作用域然后顺着最邻近的作用域去寻找匹配。全局变量可以被访问到(如果是可变类型,其甚至可以被改变),...
  • python-guide, python 最佳实践指南,为人类编写 到 python的指南python 最佳实践指南 工作。如果你愿意帮助,请执行下列操作。 还有很多工作要做。 本指南目前正在开发中。 这个自动化指南为初学者和专家 python ...
  • python-guide:为人类编写的Python最佳实践指南
  • 为人类编写的Python最佳实践指南
  • Python最佳实践指南(彩色阅读版).pdf》带目录版本
  • python 最佳实践总结

    千次阅读 2013-07-24 13:23:20
    二、语法最佳实践: 字符串操作 :优于python 字符串对象是不可改变的,因此对任何字符串的操作如拼接,修改等都将产生一个新的字符串对象,而不是基于原字符串,因此这种持续的 copy会在一定程度上影响...

    来源:http://www.atatech.org/article/detail/9463/0?ticket=0ec08e00-4a5a-4b2b-b601-62ec01a3876d

    一、数据结构的选择:

         1. 在列表中查找:

       对于已经排序的列表考虑用bisect模块来实现查找元素,该模块将使用二分查找实现

    1 def find(seq, el) :
    2     pos = bisect(seq, el)
    3     if pos == 0 or ( pos == len(seq) and seq[-1] != el ) :
    4         return -1
    5     return pos - 1

        而快速插入一个元素可以用:

    1 bisect.insort(list, element)

    这样就插入元素并且不需要再次调用 sort() 来保序,要知道对于长list代价很高.

        2. set代替列表: 

        比如要对一个list进行去重,最容易想到的实现:

    1 seq = ['a''a''b']
    2 res = []
    3 for in seq:
    4     if not in res:
    5         res.append(i)

    显然上面的实现的复杂度是O(n2),若改成:

    1 seq = ['a''a''b']
    2 res = set(seq)

    复杂度马上降为O(n),当然这里假定set可以满足后续使用。

    另外,set的union,intersection,difference等操作要比列表的迭代快的多,因此如果涉及到求列表交集,并集或者差集等问题可以转换为set来进行,平时使用的时候多注意下,特别当列表比较大的时候,性能的影响就更大。

        3. 使用python的collections模块替代内建容器类型:

    collections有三种类型:

    1. deque:增强功能的类似list类型
    2. defaultdict:类似dict类型
    3. namedtuple:类似tuple类型

           列表是基于数组实现的,而deque是基于双链表的,所以后者在中间or前面插入元素,或者删除元素都会快很多。 

           defaultdict为新的键值添加了一个默认的工厂,可以避免编写一个额外的测试来初始化映射条目,比dict.setdefault更高效,引用python文档的一个例子:

    #使用profile stats工具进行性能分析

    01 >>> from pbp.scripts.profiler import profile, stats
    02 >>> s = [('yellow'1), ('blue'2), ('yellow'3),
    03 ... ('blue'4), ('red'1)]
    04 >>> @profile('defaultdict')
    05 ... def faster():
    06 ... d = defaultdict(list)
    07 ... for k, v in s:
    08 ... d[k].append(v)
    09 ...
    10 >>> @profile('dict')
    11 ... def slower():
    12 ... d = {}
    13 ... for k, v in s:
    14 ... d.setdefault(k, []).append(v)
    15 ...
    16 >>> slower(); faster()
    17 Optimization: Solutions
    18 306 ]
    19 >>> stats['dict']
    20 {'stones'16.587882671716077'memory'396,
    21 'time': <strong>0.35166311264038086</strong>}
    22 >>> stats['defaultdict']
    23 {'stones'6.5733464259021686'memory'552,
    24 'time': <strong>0.13935494422912598</strong>}

    可见性能提升了快3倍。defaultdict用一个list工厂作为参数,同样可用于内建类型,比如long等。

     

    除了实现的算法、架构之外,python提倡简单、优雅。所以正确的语法实践又很有必要,这样才会写出优雅易于阅读的代码。

    二、语法最佳实践:

    1. 字符串操作:优于python字符串对象是不可改变的,因此对任何字符串的操作如拼接,修改等都将产生一个新的字符串对象,而不是基于原字符串,因此这种持续的 copy会在一定程度上影响Python的性能:

            (1)用join代替 '+' 操作符,后者有copy开销;

            (2)同时当对字符串可以使用正则表达式或者内置函数来处理的时候,选择内置函数。如str.isalpha(),str.isdigit(),str.startswith((‘x’, ‘yz’)),str.endswith((‘x’, ‘yz’))

            (3)字符格式化操作优于直接串联读取:

    1 str = "%s%s%s%s" % (a, b, c, d)  # efficient
    2 str = "" + a + b + c + d + ""  # slow

        2. 善用list comprehension(列表解析)  & generator(生成器) & decorators(装饰器),熟悉itertools等模块

           (1) 列表解析,我觉得是python2中最让我印象深刻的特性,举例1:

    01 >>> # the following is not so Pythonic 
    02 >>> numbers = range(10)
    03 >>> i = 0
    04 >>> evens = []
    05 >>> while i < len(numbers):
    06 >>>    if %2 == 0: evens.append(i)
    07 >>>    i += 1
    08 >>> [02468]
    09  
    10 >>> # the good way to iterate a range, elegant and efficient
    11 >>> evens = [ i for in range(10if i%2 == 0]
    12 >>> [02468]

       举例2:

    1 def _treament(pos, element):
    2     return '%d: %s' % (pos, element)<br>
    01 = open('test.txt''r')
    02 if __name__ == '__main__':
    03     #list comps 1
    04     print sum(len(word) for line in for word in line.split())
    05     #list comps 2
    06     print [(x + 1, y + 1for in range(3for in range(4)]
    07     #func
    08     print filter(lambda x: x % 2 == 0range(10))
    09     #list comps3
    10     print [i for in range(10if % 2 == 0]
    11     #list comps4 pythonic
    12     print [_treament(i, el) for i, el in enumerate(range(10))]
    13  
    14 output:
    15 24
    16 [(11), (12), (13), (14), (21), (22), (23), (24), (31), (32), (33), (34)]
    17 [02468]
    18 [02468]
    19 ['0: 0''1: 1''2: 2''3: 3''4: 4''5: 5''6: 6''7: 7''8: 8''9: 9']<br>

    没错,就是这么优雅简单。

       (2) 生成器表达式在python2.2引入,它使用'lazy evaluation'思想,因此在使用内存上更有效。引用python核心编程中计算文件中最长的行的例子:

    1 = open('/etc/motd, 'r')
    2 longest = max(len(x.strip()) for in f)
    3 f.close()
    4 return longest

    这种实现简洁而且不需要把文件文件所有行读入内存。

           (3) python在2.4引入装饰器,又是一个让人兴奋的特性,简单来说它使得函数和方法封装(接收一个函数并返回增强版本的函数)更容易阅读、理解。'@'符号是装饰器语法,你可以装饰一个函数,记住调用结果供后续使用,这种技术被称为memoization的,下面是用装饰器完成一个cache功能:

    01 import time
    02 import hashlib
    03 import pickle
    04 from itertools import chain
    05 cache = {}
    06 def is_obsolete(entry, duration):
    07     return time.time() - entry['time'] > duration
    08  
    09 def compute_key(function, args, kw):
    10     #序列化/反序列化一个对象,这里是用pickle模块对函数和参数对象进行序列化为一个hash值
    11     key = pickle.dumps((function.func_name, args, kw))
    12     #hashlib是一个提供MD5和sh1的一个库,该结果保存在一个全局字典中
    13     return hashlib.sha1(key).hexdigest()
    14  
    15 def memoize(duration=10):
    16     def _memoize(function):
    17         def __memoize(*args, **kw):
    18             key = compute_key(function, args, kw)
    19  
    20             # do we have it already
    21             if (key in cache and
    22                 not is_obsolete(cache[key], duration)):
    23                 print 'we got a winner'
    24                 return cache[key]['value']
    25  
    26             # computing
    27             result = function(*args, **kw)
    28             # storing the result
    29             cache[key] = {'value': result,-
    30                             'time': time.time()}
    31             return result
    32         return __memoize
    33     return _memoize
    34  
    35 @memoize()
    36 def very_very_complex_stuff(a, b, c):
    37     return + + c
    38  
    39 print very_very_complex_stuff(222)
    40 print very_very_complex_stuff(222)
    41  
    42  
    43 @memoize(1)
    44 def very_very_complex_stuff(a, b):
    45     return + b
    46  
    47 print very_very_complex_stuff(22)
    48 time.sleep(2)
    49 print very_very_complex_stuff(22)
    1 <br>

    运行结果:

    6

    we got a winner

    6

    4

    4

    装饰器在很多场景用到,比如参数检查、锁同步、单元测试框架等,有兴趣的人可以自己进一步学习。

        3.  善用python强大的自省能力(属性和描述符):自从使用了python,真的是惊讶原来自省可以做的这么强大简单,关于这个话题,限于内容比较多,这里就不赘述,后续有时间单独做一个总结,学习python必须对其自省好好理解。

    三、 编码小技巧:

    1. 在python3之前版本使用xrange代替range,因为range()直接返回完整的元素列表而xrange()在序列中每次调用只产生一个整数元素,开销小。(在python3中xrange不再存在,里面range提供一个可以 遍历任意长度的范围的iterator)
    2. if done is not None比语句if done != None更快;
    3. 尽量使用"in"操作符,简洁而快速: for i in seq: print i
    4. 'x < y < z'代替'x < y and y < z';
    5. while 1要比while True更快, 因为前者是单步运算,后者还需要计算;
    6. 尽量使用build-in的函数,因为这些函数往往很高效,比如add(a,b)要优于a+b;
    7. 在耗时较多的循环中,可以把函数的调用改为内联的方式,内循环应该保持简洁。
    8. 使用多重赋值来swap元素:

      1 x, y = y, x  # elegant and efficient

               而不是:

      1 temp = x
      2 = y
      3 = temp

          9. 三元操作符(python2.5后):V1 if X else V2,避免使用(X and V1) or V2,因为后者当V1=""时,就会有问题。

          10. python之switch case实现:因为switch case语法完全可用if else代替,所以python就没  有switch case语法,但是我们可以用dictionary或lamda实现:

    1 switch case结构:
    1 switch (var)
    2 {
    3     case v1: func1();
    4     case v2: func2();
    5     ...
    6     case vN: funcN();
    7     default: default_func();
    8 }

    dictionary实现:

    1 values = {
    2            v1: func1,
    3            v2: func2,
    4            ...
    5            vN: funcN,
    6          }
    7 values.get(var, default_func)()

    lambda实现:

    1 {
    2   '1'lambda: func1,
    3   '2'lambda: func2,