IT评测·应用市场-qidao123.com

标题: 你做的 9 件事表明你不是专业的 Python 开发人员 [打印本页]
作者: 忿忿的泥巴坨    时间: 2023-4-12 00:14
标题: 你做的 9 件事表明你不是专业的 Python 开发人员
本文转载自国外论坛 medium，原文地址：
https://medium.com/navan-tech/7-java-features-you-might-not-have-heard-of-adee8166d942，由博主简译后给大家带来!
Show me your code and I will tell you who you are.
This article will fix the bad habits you have stuck to over the years or brought from other programming languages.
是的，老外就这么吊，文章开头就是"给我看看你的代码，我来告诉你，你有几斤几两!"
紧接着，老外告诉你这篇文章为什么这么吊，意思是这篇文章可以纠正你多年以来从其他语言坚持而来的坏习惯。。。虽然博主确实编了几年程序。
一、手动格拼接字符串

大多数时候，Python 初学者在组合两个字符串时会使用 + 号。
  1. >>> name = "Ridwan"
  2. >>> age = "22"
  3. >>> print("My Name is " + name + " and I am " + age + " years old")
  4. My Name is Ridwan and I am 22 years old
复制代码
不要使用 + 号，而应使用 f 字符串，这样可以使您的代码可读、简洁且不易出错。python3.6+开始支持 f 格式字符串
  1. >>> print(f"My Name is {name} and I am {age} years old")
  2. My Name is Ridwan and I am 22 years old
复制代码
二、使用默认可变参数

在 Python 中，只要您将可变值作为参数传递给函数，默认参数就会在函数被调用时发生变化。这些可变参数通常是列表或字典。
如下：
  1. >>> def append(n, l=[]):
  2. ...     l.append(n)
  3. ...     return l
  4. ...
复制代码
可以看到 append 函数的第二个参数 l 是一个可变参数，只要您使用值为 n 调用该函数，它就会更改默认值 l。
  1. // 第一次调用
  2. >>> l1 = append(0)
  3. >>> l1
  4. [0]
复制代码
当您下次在调用 append 函数时，您将看到您使用的先前值附加到空列表参数。
  1. // 第二次调用
  2. >>> l2 = append(1)
  3. >>> l2
  4. [0, 1]
复制代码
简而言之也就是说由于 l 在 append 函数中被默认初始化为一个 list，第二次调用时，l 并没有重置，导致返回时还带有第一次调用的结果。
这个问题可以通过重写代码来解决，
  1. >>> def append(n, l = None):
  2. ...     if l is None:
  3. ...         l = []
  4. ...     l.append(n)
  5. ...     return l
  6. ...
  7. >>> l1 = append = [0]
  8. >>> l2 = append = [1]
  9. >>> l1,l2
  10. ([0], [1])
复制代码
现在参数 l 被设置为 None，任何时候函数被调用，即使 l 发生了变化，它也会被重新分配为 None，然后给出一个空列表的值。
三、不使用推导式

Python 推导式 为您提供了一种构建序列的简洁方式，上次我检查过，Python 支持 4 种类型的推导式；
你可以在这里阅读更多关于他们的信息。
下面的代码将字典中的值除以 2，
  1. >>> numbers = {}
  2. >>> for i in range(10):
  3. ...     numbers[i] = i/2
  4. ...
  5. >>> numbers
  6. {0: 0.0, 1: 0.5, 2: 1.0, 3: 1.5, 4: 2.0, 5: 2.5, 6: 3.0, 7:
  7. 3.5, 8: 4.0, 9: 4.5}
复制代码
上面的代码可以写成一行，
  1. >>> {i: i/2 for i in range(10)}
  2. {0: 0.0, 1: 0.5, 2: 1.0, 3: 1.5, 4: 2.0, 5: 2.5, 6: 3.0, 7:
  3. 3.5, 8: 4.0, 9: 4.5}
复制代码
所以不要让自己过得不好，开始使用推导式。
推导式确实算是 python 开发一大利器，用好推导式，早下班！
四、检查 Equality 而不是 Identity

如下,
  1. a = [1, 2, 3]
  2. b = [1, 2, 3]
复制代码
如果我让你检查这两个变量是否相同，你首先想到的是，
  1. >>> a == b
  2. True
复制代码
问题是你需要知道 Identity 和 Equality 之间的区别。
如果检查a和b的内存地址，
  1. >>> id(a), id(b)
  2. (1838093945856, 1838093487488)
复制代码
您可以看到尽管它们具有相同的对象，但它们都有不同的内存地址。
这就是为什么当你运行代码时，
  1. >>> a == b
  2. TrueYou get True, but when you run>>> a is bFalse
复制代码
当你调用 a is b 返回 False时，a 和 b 就不是相等的了。
在运行如下代码，
  1. >>> c = [1,2,3]
  2. >>> d = c
  3. >>> id(c), id(d)
  4. (1838089019712, 1838089019712)
复制代码
可以看到，c和d是相等且相同的，c中的对象也被赋值给了d。
  1. >>> c == d
  2. True
  3. >>> c is d
  4. True
复制代码
这意味着 c 和 d 具有相同的值和内存地址。
因此你可以说 c 是相同的并且等于 d。
写这篇文章就是为了让你知道 is 和 == 的区别，前者是用来检查 identity ，后者是用来检查 equality 的。
所有相同的变量都相等，但并非所有相等的变量都相同。
这一段看着有点绕，说人话就是 == 比较的是连个变量的值是否相等，is 比较的是两个比变量的内存地址相等!，我相信大伙都明白哈，不然白看了这么多年八股文。

五、不使用元组解包

任何时候你在 Python 中创建一个元组 a_tuple = 1,2,3 ，它会默认进行元组打包，
  1. >>> a_tuple = 1,2,3
  2. >>> a_tuple
  3. (1, 2, 3)
复制代码
然后可以通过索引访问元组内元素
  1. >>> x = a_tuple[0]
  2. >>> y = a_tuple[1]
  3. >>> z = a_tuple[2]
  4. >>> print(x, y, z)
  5. 1, 2, 3
复制代码
其实无需使用多行代码访问元组中的元素，您可以通过元组解包自动在一行代码中完成。
  1. >>> x,y,z = a_tuple
  2. >>> print(x, y, z)
  3. 1, 2, 3
复制代码
元组解包也是 python 中常用的开发技巧，提升开发效率。
六、创建您自己的索引计数器变量

这个在其他编程语言中很常见，你被要求创建一个索引计数器变量，然后你输入类似的东西；
  1. >>> a_list = [1,2,3,4,5,6,7,8,9,10]
  2. >>> index = 0
  3. >>> for elem in a_list:
  4. ...     print(index, elem)
  5. ...     index += 1
  6. ...
  7. 0 1
  8. 1 2
  9. 2 3
  10. 3 4
  11. 4 5
  12. 5 6
  13. 6 7
  14. 7 8
  15. 8 9
  16. 9 10
复制代码
相反，使用 enumerate 函数使您的代码看起来像 Pythonic（这里指写出python风格的代码）；
  1. >>> for index, elem in enumerate(a_list):
  2. ...     print(index, elem)
  3. ...
  4. 0 1
  5. 1 2
  6. 2 3
  7. 3 4
  8. 4 5
  9. 5 6
  10. 6 7
  11. 7 8
  12. 8 9
  13. 9 10
复制代码
这里批评下 Java，这么多年了，foreach 循环也拿不到索引。
七、使用 Print 语句代替日志记录模块

这在小型项目中可能无关紧要，但肯定会对大型项目有所帮助。
不要用打印语句乱扔代码，而是使用日志记录。
  1. >>> print('This is a warning message')
  2. This is a warning message
  3. >>> print('This is an error message')
  4. This is an error message
  5. >>> print('This is a critical message')
  6. This is a critical message
复制代码
日志记录有助于向您的用户显示有用的消息，以增加对代码库中发生的事情的更多上下文和理解。
  1. >>> import logging
  2. >>> logging.warning('This is a warning message')
  3. WARNING:root:This is a warning message
  4. >>> logging.error('This is an error message')
  5. ERROR:root:This is an error message
  6. >>> logging.critical('This is a critical message')
  7. CRITICAL:root:This is a critical message
复制代码
这年头还有人在线上不用文件记录日志吗？有的话告诉我一声，
我肯定拿刀找他!
八、使用 import * 在命名模块中导入函数和类

这种坏习惯有时在新手中很常见。
使用 import * 导入会破坏您的命名空间，方法是将该命名模块中的所有函数和类导入您的代码，这可能会与您定义的函数或导入的其他库的函数发生冲突。
反正博主从来不用 import *，至于你用不用我不知道，但是我建议你不要用。
九、不关注 pep8

pep8就是Python官方指定的编码规范
我们大多数人都犯了这个罪，
我承认我有罪

在我被取消之前
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 IT评测·应用市场-qidao123.com (https://dis.qidao123.com/) Powered by Discuz! X3.4