精华内容
下载资源
问答
  • 1. 重构代码(《重构》的python实现): ...每当你在代码库中看到以下的模式可以参照以下的建议进行重构,让代码变得更加的pythonic,可读性更好,更容易维护。 参考:Python重构代码的一些模式 ...

    蓝色的 mandelbrot

    1. 重构代码(《重构》的python实现):

    常量和临时变量

    • 提取常量
    • 加入解释性变量
    • 分解临时变量(单一原则)
    • 去除临时变量
    • 移除控制标记(直接return 或 break)

      函数

    • 拆分
    • 去除(去除简单的)
    • 合并多个函数,使用参数
    • 函数不应有副作用,单一职责原则,一个函数不应做两件事,函数粒度尽量小

      表达式

    • 过多的条件逻辑, 难以理解正常的执行路径. 在python中的特征是, 缩进太深(尽早return 改为平行的 if)
    • 合并条件表达式(对于返回结果相同的条件)
    • 分解复杂条件表达式(分别从if,else中提炼出独立函数)
    • 合并重复的代码片段(if 和 else都有的代码,放到外面去)

    参数及返回值

    • 提取对象(如果参数/返回值是一组相关的数值, 且总是一起出现, 可以考虑提取成一个对象)
    • 减少参数(中间不需要的步骤)
    def get_width_height():
        ....
    
        return width, height
    
    def get_area(width, height):
        return width, height
    # to
    class Rectangle(object):
        def __init__(self, width, height):
            self.width = width
            self.height = height
    
        def area(self):
            return self.width * self.height
    
    def get_shape():
        ....
        return Rectangle(height, width)

    • 搬移,函数/字段
    • 拆分类
    • 去除类 (类做的事不多,不再独立存在)

      模式

    • 慎用,只用熟悉的,只用符合业务场景的
    • 装饰器

    参考:http://www.wklken.me/posts/2017/06/17/refactoring-07.html#yuan-ze

    2. pycharm重构快捷键

    序号 快捷键 功能
    1 F5 复制文件
    2 F6 移动文件
    3 SHIFT F6 重命名
    4 ALT delete 安全删除
    5 CTRL F6 改变函数形参
    6 CTRL ALT M 将代码提取为函数
    7 CTRL ALT V 将代码提取为变量
    8 CTRL ALT C 将代码提取为常数
    9 CTRL ALT F 将代码提取为字段
    10 CTRL ALT P 将代码提取为参数

    3. python idiom, pythonic

    每当你在代码库中看到以下的模式可以参照以下的建议进行重构,让代码变得更加的pythonic,可读性更好,更容易维护。
    参考:Python重构代码的一些模式 http://mpwang.github.io/2017/08/26/python-refactor-patterns/

    enumerate

    需要使用列表的下标时,不要使用C风格的下标遍历

    lst = ['a', 'b', 'c']
    # DON'T
    i = 0
    for i in lst:
        print i, '-->', lst[i]
        i += 1
    # OR
    for i in range(len(lst)):
        print(i, '-->', lst[i])
    # DO
    for idx, item in enumerate(lst):
        print(idx, '-->', item)
    

    zip/izip

    同时遍历两个列表时,不要使用C风格的下标遍历

    lst1 = ['a', 'b', 'c']
    lst2 = [1, 2, 3]
    # DON'T
    for i in range(len(lst1)):
        print(lst1[i])
        print(lst2[i])
    # DO
    for lst1_item, lst2_item in zip(lst1, lst2):
        print(lst1_item)
        print(lst2_item)
    # BETTER
    # 不需要在内存中生成包含lst, lst2的第三个列表
    from itertools import izip
    for lst1_item, lst2_item in izip(lst1, lst2):
        print(lst1_item)
        print(lst2_item)
    

    unpacking tuple

    x, y = y, x
    foo, bar, _ = words # 使用 _ 如果你不需要这个值

    Dict.setdefault/defaultdict

    处理字典中key不存在时的默认值

    # group words by frequency
    words = [(1, 'apple'), (2, 'banana'), (1, 'cat')]
    frequency = {}
    # DON'T
    for freq, word in words:
        if freq not in frequency:
            frequency[freq] = []
        frequency[freq].append(word)
    # DO
    for freq, word in words:
        frequency.setdefault(freq, []).append(word)
    # BETTER
    from collections import defaultdict
    frequency = defaultdict(list)
    for freq, word in words:
        frequency[freq].append(word)
    # 在工作中要经常处理字典为空或键值不存在的情形,用get和setdefault代替dict_name['key']

    setdefault vs get
    setdefault()的使用,类似get方法,如果字典中包含有给定键,则返回该键对应的值,否则返回为该键设置的值
    不同点:1.setdefault会把不存在的item保存到原来的dict,2.setdefault比get快10percent

    person_dict = {}
    person_dict['liqi'] = 'LiQi'
    person_dict.setdefault('liqi', 'Liqi')  # 'LiQi'
    person_dict.setdefault('Kim', 'kim')  # 'kim'
    person_dict
    person_dict.get('Dim', 'D')  # 'D'
    person_dict  # {'liqi': 'LiQi', 'Kim': 'kim'}
    

    Dict.iteritems

    遍历字典

    words = {'apple': 1, 'banana': 2, 'cat': 3}
    # OK
    for word in words:
        print word, '-->', words[word] # 需要计算word的hash值
    # GOOD
    for word, freq in words.items():
        print word, '-->', freq
    # BETTER
    # 不需要在内存中生存包含words所有元素的中间结果
    for word, freq in words.iteritems():
        print word, '-->', freq
    

    for...else

    break and nobreak

    # DO
    for word in words:
        if condition(word):
            # 处理存在符合condition的元素的情况
            print 'Found'
            break
    else:
        # 处理没有符合condition元素的情况
        print 'Not found'

    try...except...else

    分开异常处理与正常情况

    # GOOD
    try:
        result = json.loads(get_external_json())
        do_something_with(result)
    except Exception as e:
        handle_error(e)
    # BETTER
    try:
        # 异常可能抛出点
        result = json.loads(get_external_json())
    except Exception as e:
        # 异常处理
        handle_error(e)
    else:
        # 正常情况
        do_something_with(result)
    

    https://medium.com/the-andela-way/idiomatic-python-coding-the-smart-way-cc560fa5f1d6

    1. chained comparison operators

    # bad
    if x <= y and y <= z:
      # do something
    # good
    if x <= y <= z:
      # do something

    2. indentation(if else )

    3. use the falsy & truthy concepts

    For example an empty list/sequences [], empty dictionaries {} None, False, Zero for numeric types, are considered “falsy”. On the other hand, almost everything else is considered “truthy”.

    # bad
    x = True
    y = 0
    if x == True:
      # do something
    elif x == False:
      # do something else
    if y == 0:
      # do something
    ls = [2, 5]
    if len(ls) > 0:
      # do something
    # good
    (x, y) = (True, 0)
    # x is truthy
    if x:
      # do something
    else:
      # do something else
    # y is falsy
    if not y:
      # do something
    ls = [2, 5]
    if ls:
      # do something

    4. ternary operator replacement

    # bad
    a = True
    value = 0
    if a:
      value = 1
    print(value)
    # good
    a = True
    value = 1 if a else 0
    print(value)
    

    5. use the 'in' keyword

    # bad
    city = 'Nairobi'
    found = False
    if city == 'Nairobi' or city == 'Kampala' or city == 'Lagos':
      found = True
    # good
    city = 'Nairobi'
    found = city in {'Nairobi', 'Kampala', 'Lagos'}

    6. Use ‘return’ to evaluate expressions, in addition to return values

    # bad
    def check_equal(x, y):
      result = False
    
      if x == Y:
        result = True
      return result
    # good
    def check_equal(x, y):
      return x == y

    7. multiple assignment

    # good
    x = y = z = 'foo'

    8. formatting strings

    def user_info(user):
      return 'Name: {user.name} Age: {user.age}'.format(user=user)
    

    9. list comprehension(set, dict)

    ls = [element for element in range(10) if not(element % 2)]
    emails = {user.name: user.email for user in users if user.email}

    10. sets

    ls1 = [1, 2, 3, 4, 5]
    ls2 = [4, 5, 6, 7, 8]
    elements_in_both = list( set(ls1) & set(ls2) )
    print(elements_in_both)
    

    11. dont't repeat yourself(dry)

    # bad
    if user:
      print('------------------------------')
      print(user)
      print('------------------------------')
    # good
    if user:
      print('{0}\n{1}\n{0}'.format('-'*30, user))
    

    转载于:https://www.cnblogs.com/bruspawn/p/9236379.html

    展开全文
  • Pythonic定义Pythonic确实很难定义,先简单引用下《Python之禅》中的几句经典阐释:优美胜于丑陋(Python 以编写优美的代码为目标)明了胜于晦涩(优美的代码应当是明了的,命名规范,风格相似)简洁胜于复杂(优美...

    Pythonic定义

    Pythonic确实很难定义,先简单引用下《Python之禅》中的几句经典阐释:

    优美胜于丑陋(Python 以编写优美的代码为目标)

    明了胜于晦涩(优美的代码应当是明了的,命名规范,风格相似)

    简洁胜于复杂(优美的代码应当是简洁的,不要有复杂的内部实现)

    复杂胜于凌乱(如果复杂不可避免,那代码间也不能有难懂的关系,要保持接口简洁)

    扁平胜于嵌套(优美的代码应当是扁平的,不能有太多的嵌套)

    间隔胜于紧凑(优美的代码有适当的间隔,不要奢望一行代码解决问题)

    可读性很重要(优美的代码是可读的)

    举个简单的例子,使用Pythonic风格编码的快速排序算法代码如下所示:

    defquicksort(array):

    less=[];

    greater=[];if len(array) <= 1:returnarray

    pivot=array.pop()for x inarray:if x <=pivot:

    less.append(x)else:

    greater.append(x)return quicksort(less) + [pivot] + quicksort(greater)

    Pythonic代码风格

    交换两个变量

    C语言代码如下:

    1 int a = 1, b = 2;2 int tmp =a;3 a =b;4 b =tmp;5

    6 //如果两个变量都为整数类型,当然也可使用:7

    8 int a = 1, b = 2;9 a = a^b;10 b = a^b;11 a = a^b;12

    13 //这样的形式,可以不用引入第三个变量

    Pythonic代码如下:

    1 a, b = b, a

    Python可以灵活的使用迭代器,安全的关闭文件描述符,如下:

    1 for i inalist:2 do_sth_with(i)3

    4 with open(path, "r") as f:5 do_sth_with(f)

    Pythonic追求的是对Python语法的充分发挥,写出的代码带Python味儿,而不是看着向C或JAVA代码;

    不应过分使用技巧

    1 a = [1, 2, 3, 4]2 b = "abcdef"

    3 print a[::-1]4 print b[::-1]

    使用Python比较多的人可以比较容易看出其作用,就是输出逆序的a和b,但还是比较晦涩,Pythonic追求的是充分利用Python语法,上面代码可写为:

    1 a = [1, 2, 3, 4]2 b = "abcdef"

    3 printlist(reversed(a))4 print list(reversed(b))

    字符串格式化

    我们很多人一般这样写,比较简洁:

    1 name = "Tom"

    2 age = "20"

    3 print "Hello %s, your age is %s !" % (name, age)

    其实,%s是比较影响可读性的,尤其是数量多了之后,很难清楚哪个占位符对应哪个实参,比较Pythonic的代码如下:

    1 value = {"name": "Tom", "age": "20"}2 print "Hello %(name)s, your age is %(age)s !" % value

    使用%占位符的形式,依旧不是Python最推荐的,最具Pythonic风格的代码如下:

    1 print "Hello {name}, your age is {age} !".format(name = "Tom", age = "20")

    str.format()是Python最为推荐的字符串格式化方法;

    包和模块

    包和模块的命名采用小写、单数形式,而且短小;

    包通常仅作为命名空间,可以只包含空的__init__.py文件;

    过多的if...elif...elif......else...应使用字典来实现

    1 if n ==0:2 print "You typed zero..."

    3 elif n == 1:4 print "You are in top..."

    5 elif n == 2:6 print "n is even number..."

    7 else:8 print "Default value"

    9

    10 #使用字典来实现更好一些

    11

    12 deff(x):13 return{14 0: "You typed zero...",15 1: "You are in top...",16 2: "n is even number...",17 }.get(x, "Default value")

    编写Pythonic代码

    避免劣化代码

    避免只用大小写来区分不同的对象;

    避免使用容易引起混淆的名称,变量名应与所解决的问题域一致;

    不要害怕过长的变量名;

    代码中添加适当注释

    行注释仅注释复杂的操作、算法,难理解的技巧,或不够一目了然的代码;

    注释和代码要隔开一定的距离,无论是行注释还是块注释;

    给外部可访问的函数和方法(无论是否简单)添加文档注释,注释要清楚地描述方法的功能,并对参数,返回值,以及可能发生的异常进行说明,使得外部调用的人仅看docstring就能正确使用;

    推荐在文件头中包含copyright申明,模块描述等;

    注释应该是用来解释代码的功能,原因,及想法的,不该对代码本身进行解释;

    对不再需要的代码应该将其删除,而不是将其注释掉;

    适当添加空行使代码布局更为优雅、合理

    在一组代码表达完一个完整的思路之后,应该用空白行进行间隔,推荐在函数定义或者类定义之间空两行,在类定义与第一个方法之间,或需要进行语义分隔的地方空一行,空行是在不隔断代码之间的内在联系的基础上插入的;

    尽量保证上下文语义的易理解性,一般是调用者在上,被调用者在下;

    避免过长的代码行,每行最好不要超过80字符;

    不要为了保持水平对齐而使用多余的空格;

    编写函数的几个原则

    函数设计要尽量短小,嵌套层次不宜过深;

    函数申明应做到合理、简单、易于使用,函数名应能正确反映函数大体功能,参数设计应简洁明了,参数个数不宜过多;

    函数参数设计应考虑向下兼容;

    一个函数只做一件事,尽量保证函数语句粒度的一致性;

    将常量集中到一个文件

    Python没有提供定义常量的直接方式,一般有两种方法来使用常量;

    通过命名风格来提醒使用者该变量代表的意义为常量,如常量名所有字母大写,用下划线连接各个单词,如MAX_NUMBER,TOTLE等;

    通过自定义的类实现常量功能,常量要求符合两点,一是命名必须全部为大写字母,二是值一旦绑定便不可再修改;

    1 class_const:2

    3 class ConstError(TypeError): pass

    4 class ConstCaseError(ConstError): pass

    5

    6 def __setattr__(self, name, value):7 if name in self.__dict__:8 rasie self.ConstError, "Can"t change const.%s" %name9 if notname.isupper():10 raise self.ConstCaseError, "const name "%s" is not all uppercase" %name11

    12 self.__dict__[name] =value13

    14 importsys15 sys.modules[__name__] = _const()

    无论是用哪种方式,都应该将常量集中到一个文件中,便于维护管理;

    ——《编写高质量代码》读后总结

    展开全文
  • Pythonic定义 ... Pythonic确实很难定义,先简单引用下《Python之禅》中的几句经典阐释: ...明了胜于晦涩(优美的代码应当是明了的,命名规范,风格相似) 简洁胜于复杂(优美的代码应当是简洁的,不要有复杂...

    Pythonic定义

    Python最常用的编码风格还是PEP8,详见:http://jython.cn/dev/peps/pep-0008/

    Pythonic确实很难定义,先简单引用下《Python之禅》中的几句经典阐释:

    优美胜于丑陋(Python 以编写优美的代码为目标)
    明了胜于晦涩(优美的代码应当是明了的,命名规范,风格相似)
    简洁胜于复杂(优美的代码应当是简洁的,不要有复杂的内部实现)
    复杂胜于凌乱(如果复杂不可避免,那代码间也不能有难懂的关系,要保持接口简洁)
    扁平胜于嵌套(优美的代码应当是扁平的,不能有太多的嵌套)
    间隔胜于紧凑(优美的代码有适当的间隔,不要奢望一行代码解决问题)
    可读性很重要(优美的代码是可读的)

    举个简单的例子,使用Pythonic风格编码的快速排序算法代码如下所示:

    def quicksort(array):
        less = [];
        greater = [];
    
        if len(array) <= 1:
            return array
        pivot = array.pop()
        for x in array:
            if x <= pivot:
                less.append(x)
            else:
                greater.append(x)
    
        return quicksort(less) + [pivot] + quicksort(greater)

    Pythonic代码风格

    • 交换两个变量

    C语言代码如下:

     1 int a = 1, b = 2;
     2 int tmp = a;
     3 a = b;
     4 b = tmp;
     5 
     6 //如果两个变量都为整数类型,当然也可使用:
     7 
     8 int a = 1, b = 2;
     9 a = a^b;
    10 b = a^b;
    11 a = a^b;
    12 
    13 //这样的形式,可以不用引入第三个变量

    Pythonic代码如下:

    1 a, b = b, a
    • Python可以灵活的使用迭代器,安全的关闭文件描述符,如下:
    1 for i in alist:
    2     do_sth_with(i)
    3 
    4 with open(path, 'r') as f:
    5     do_sth_with(f)

    Pythonic追求的是对Python语法的充分发挥,写出的代码带Python味儿,而不是看着向C或JAVA代码;

    • 不应过分使用技巧
    1 a = [1, 2, 3, 4]
    2 b = 'abcdef'
    3 print a[::-1]
    4 print b[::-1]

    使用Python比较多的人可以比较容易看出其作用,就是输出逆序的a和b,但还是比较晦涩,Pythonic追求的是充分利用Python语法,上面代码可写为:

    1 a = [1, 2, 3, 4]
    2 b = 'abcdef'
    3 print list(reversed(a))
    4 print list(reversed(b))
    • 字符串格式化

    我们很多人一般这样写,比较简洁:

    1 name = 'Tom'
    2 age = '20'
    3 print 'Hello %s, your age is %s !' % (name, age)

    其实,%s是比较影响可读性的,尤其是数量多了之后,很难清楚哪个占位符对应哪个实参,比较Pythonic的代码如下:

    1 value = {'name': 'Tom', 'age': '20'}
    2 print 'Hello %(name)s, your age is %(age)s !' % value

    使用%占位符的形式,依旧不是Python最推荐的,最具Pythonic风格的代码如下:

    1 print 'Hello {name}, your age is {age} !'.format(name = 'Tom', age = '20')

    str.format()是Python最为推荐的字符串格式化方法;

    • 包和模块

    包和模块的命名采用小写、单数形式,而且短小;

    包通常仅作为命名空间,可以只包含空的__init__.py文件;

    • 过多的if...elif...elif......else...应使用字典来实现
     1 if n == 0:
     2     print "You typed zero..."
     3 elif n == 1:
     4     print "You are in top..."
     5 elif n == 2:
     6     print "n is even number..."
     7 else:
     8     print "Default value"
     9 
    10 # 使用字典来实现更好一些
    11 
    12 def f(x):
    13     return {
    14         0: "You typed zero...",
    15         1: "You are in top...",
    16         2: "n is even number...",
    17     }.get(x, "Default value")

    编写Pythonic代码

    避免劣化代码

    • 避免只用大小写来区分不同的对象;
    • 避免使用容易引起混淆的名称,变量名应与所解决的问题域一致;
    • 不要害怕过长的变量名;

    代码中添加适当注释

    • 行注释仅注释复杂的操作、算法,难理解的技巧,或不够一目了然的代码;
    • 注释和代码要隔开一定的距离,无论是行注释还是块注释;
    • 给外部可访问的函数和方法(无论是否简单)添加文档注释,注释要清楚地描述方法的功能,并对参数,返回值,以及可能发生的异常进行说明,使得外部调用的人仅看docstring就能正确使用;
    • 推荐在文件头中包含copyright申明,模块描述等;
    • 注释应该是用来解释代码的功能,原因,及想法的,不该对代码本身进行解释;
    • 对不再需要的代码应该将其删除,而不是将其注释掉;

    适当添加空行使代码布局更为优雅、合理

    • 在一组代码表达完一个完整的思路之后,应该用空白行进行间隔,推荐在函数定义或者类定义之间空两行,在类定义与第一个方法之间,或需要进行语义分隔的地方空一行,空行是在不隔断代码之间的内在联系的基础上插入的;
    • 尽量保证上下文语义的易理解性,一般是调用者在上,被调用者在下;
    • 避免过长的代码行,每行最好不要超过80字符;
    • 不要为了保持水平对齐而使用多余的空格;

    编写函数的几个原则

    • 函数设计要尽量短小,嵌套层次不宜过深;
    • 函数申明应做到合理、简单、易于使用,函数名应能正确反映函数大体功能,参数设计应简洁明了,参数个数不宜过多;
    • 函数参数设计应考虑向下兼容;
    • 一个函数只做一件事,尽量保证函数语句粒度的一致性;

    将常量集中到一个文件

    Python没有提供定义常量的直接方式,一般有两种方法来使用常量;

    • 通过命名风格来提醒使用者该变量代表的意义为常量,如常量名所有字母大写,用下划线连接各个单词,如MAX_NUMBER,TOTLE等;
    • 通过自定义的类实现常量功能,常量要求符合两点,一是命名必须全部为大写字母,二是值一旦绑定便不可再修改;
     1 class _const:
     2 
     3     class ConstError(TypeError): pass
     4     class ConstCaseError(ConstError): pass
     5 
     6     def __setattr__(self, name, value):
     7         if name in self.__dict__:
     8             rasie self.ConstError, "Can't change const.%s" % name
     9         if not name.isupper():
    10             raise self.ConstCaseError, "const name '%s' is not all uppercase" % name
    11 
    12         self.__dict__[name] = value
    13 
    14 import sys
    15 sys.modules[__name__] = _const()

    无论是用哪种方式,都应该将常量集中到一个文件中,便于维护管理;

     

    ——《编写高质量代码》读后总结

    转载于:https://www.cnblogs.com/pflee/p/4337573.html

    展开全文
  • python推导式pythonic必备

    千次阅读 多人点赞 2019-08-20 16:58:15
    编程规范 今天公司新出了一套Python编程规范2.0,一直觉得自己写代码路子有点野,所以仔细的看了下。 多数的内容在网上都能搜到,但有几点需要说说 让我觉得羞愧的注释率 公司要求代码注释行,占代码总行数的20%...

    编程规范

    今天公司新出了一套Python编程规范2.0,一直觉得自己写代码路子有点野,所以仔细的看了下。
    多数的内容在网上都能搜到,但有几点需要说说

    • 让我觉得羞愧的注释率
      公司要求代码注释行,占代码总行数的20%,而我经常一套代码写下来注释寥寥几行。甚至在Linux下写代码的时候,由于系统语言包问题,pycharm没办法打中文,经常出现通篇没有一行注释的情况...所谓,写自己的代码,让别人无处维护也就不过如此。但过了仗剑走天涯的年纪,要开始学着沉淀自己,不为别的,就为现在年轻的小伙子各个吃的好,长得壮。几个一起来,打不过啊,哈哈。

    • 规避单一循环
      这一点代码要求是我欣然接受的,我这人懒,能偷懒的偷懒,不能偷懒的想办法也要偷懒。这次的代码规范要求,单一辑的for循环,通过python推导式完成,但嵌套for循环禁止使用。我默默的忽略后面这句,for循环推荐python推导式....
      为什么喜欢推导式?因为省事儿、看这高端啊。最怕人说程序猿就是if ...else + for循环了....

    python推导式

    今天就给大家介绍下python推导式的使用

    推导式(又称解析式) 是Python的⼀种独有特性。

    推导式是可以从⼀个数据序列构建另⼀个新的数据序列的结构体。 共有三种推导:

    • 列表(list)推导式

    • 字典(dict)推导式

    • 集合(set)推导式


    列表推导式 (list comprehensions)

    列表推导式(又称列表解析式) 提供了⼀种简明扼要的方法来创建列表。

    它的结构是在一个中括号里包含一个表达式, 然后是一个for语句, 然后是0个或多个for或者if语句。 那个表达式可以是任意的, 意思是你可以在列表中放入任意类型的对象。 返回结果将是⼀个新的列表, 在这个以if和for语句为上下⽂的表达式运⾏完成之后产生

    规范

    variable = [x for x in list if something == 2]
    这⾥是另外⼀个简明例子:

    multiples = [i for i in range(30) if i % 3 is 0]
    print(multiples)
    # Output: [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

    列表推导式在有些情况下超赞, 特别是当你需要使⽤for循环来生成一个新列表。 举个例子, 通常一般人会这样做:

    squared = []
    for x in range(10):
        squared.append(x**2)

    你可以使⽤列表推导式来简化它:
    squared = [x**2 for x in range(10)]


    集合推导式(set comprehensions)

    至于集合推导式,跟列表推导式大同小异,不过在去重方面是set的强项
    举个栗子:

    squared = {x**2 for x in [1, 1, 2]}
    print(squared)
    # Output: {1, 4}

    字典推导式(dict comprehensions)

    字典推导式,使用的场景比较少,但是有一点是超级赞的!

    问题:遇到字典的键值对互换,你会怎么操作?

    1. 使用for循环?

    mydict={"a":1,"b":2,"c":3}
    mydict_new={}
    for key,val in mydict.items():
        mydict_new[val]=key

    2.使用zip?

    mydict={"a":1,"b":2,"c":3}
    newdict=dict(zip(mydict.values(),mydict.keys()))

    3.say no,你应该使用字典推导式!

    mydict={"a":1,"b":2,"c":3}
    newdict={v: k for k, v in some_dict.items()}
    or
    newdict=dict([val,key] for key,val in mydict.items())

    The End

    OK,如果觉得这篇文章对你有帮助,欢迎将文章或我的微信公众号【清风Python】转发分享给更多喜欢python的朋友们,谢谢。

    作者:清风Python

    展开全文
  • Pythonic方式来思考

    2017-12-04 23:43:00
    一门语言的编程习惯是由用户来确立的。这些年来,Python开发者用Pythonic这个形容词来描述那种符合特定风格的代码。 这种Pyhtonic风格,既不是严密的规范,也不是由编译器强加给开发者的规则,而是大家在使用Python...
  • 最近在学习大神 slatkin ...PEP8全称《Python Enhancement Proposal #8》,又叫做8号python增强提案,通过规范编程风格,使得自己的代码更加易懂,不同的开发人员之间可以更高效地沟通。完整指南见:https://www.py...
  • DPDK的代码规范

    2017-02-18 11:00:00
    每个公司都会有自己代码风格或者编程规范,都旨在防范编程语言的一些陷阱或者提高代码效率,还有就是保持一致编码风格来提高代码可读性,方便code review; 或者说代码的一种美学,比如python也就有pep8约定,还有...
  • 最近在看一本书《...这本书讲的并不是Python基础编程,而是Python的规范和技巧,也就是pythonicpythonic简单的翻译就是python风格。pythonic code,就是说写代码要带有浓厚的python规范和python风格。...
  • 最近在看一本书《...这本书讲的并不是Python基础编程,而是Python的规范和技巧,也就是pythonicpythonic简单的翻译就是python风格。pythonic code,就是说写代码要带有浓厚的python规范和python风格。...
  • Pythonic TDD (powered by S5 v1.1)   http://zoomquiet.org/res/s5/100826-PyTDD/  python 测试浅涉 自动化测试 演讲胶片  ... python编程规范:https://docs.g
  • 2:编程惯用法 3:基础用法 4:库 5:设计模式 6:内部机制 7:使用工具辅助项目开发 8:性能剖析与优化 1:引论 建议1、理解Pythonic概念—-详见Python中的《Python之禅》 建议2、编写Pythonic代码 避免...
  • 今天我们在此分享一些 Python 编程中的经验建议,希望对各位 Python 的学习者和使用者有帮助。 引论 建议1、理解 Pythonic 概念—-详见 Python 中的《Python之禅》 建议2、编写 Pythonic 代码 (1)避免不规范代码...
  • 一、编程前言 建议1:理解Pythonic概念 详见Python中的《Python之禅》。 Pythonic : https://www.cnblogs.com/HacTF/p/8142374.html 优美胜于丑陋(Python 以编写优美的代码为目标) 明了胜于晦涩(优美的代码应当是...
  • 另外,原文中的Pythonic一词,大意指符合Python语言规范、特性和数据结构的编码方式,蕴涵较为丰富,为了行文更顺畅、容易理解,此文暂时用简洁、优雅代替。-- <cite>EarlGrey@编程派</cite> 原文链接:...
  • 每个人都可以有自己的编程风格,但使用良好的编程规范可以帮助我们规范代码,也符合大多数人的阅读和使用习惯。 通常一些知名的大厂和团队都会有自己的编程规范,感谢分享! NO1.从现有的产品或线上中学习,如参考...
  • 每个编程语言都有自己的最佳实践.通常你不能套用别的语言来写出pythonic的代码. Python是一门初学简单,越学越难的语言. 在Python的世界中, 万物皆对象.当我们说某个对象是什么类型时,在根本上其实指的是:这个对象...
  • 代码规范程度高,可读性强 Python在以下领域都有用武之地。 后端开发 - Python / Java / Go / PHP DevOps - Python / Shell / Ruby 数据采集 - Python / C++ / Java 量化交易 - Python / C++ / R 数据科学 - ...
  • Pycco:文学编程(literate-programming)风格的文档生成器。 readthedocs:一个基于 Sphinx/MkDocs 的在线文档托管系统,对开源项目免费开放使用。 配置 用来保存和解析配置的库。 config:logging 模块作者写...

空空如也

空空如也

1
收藏数 20
精华内容 8
关键字:

pythonic编程规范

python 订阅