本文轉載自國外論壇 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 初學者在組合兩個字串時會使用 + 號，

>>> name = "Ridwan"
>>> age = "22"
>>> print("My Name is " + name + " and I am " + age + " years old")
My Name is Ridwan and I am 22 years old

不要使用 + 號，而應使用 f 字串，這樣可以使您的代碼可讀、簡潔且不易出錯，python3.6+開始支持 f 格式字串

>>> print(f"My Name is {name} and I am {age} years old")
My Name is Ridwan and I am 22 years old

二、使用默認可變引數

在 Python 中，只要您將可變值作為引數傳遞給函式，默認引數就會在函式被呼叫時發生變化，這些可變引數通常是串列或字典，

如下：

>>> def append(n, l=[]):
...     l.append(n)
...     return l
...

可以看到 append 函式的第二個引數 l 是一個可變引數，只要您使用值為 n 呼叫該函式，它就會更改默認值 l，

// 第一次呼叫
>>> l1 = append(0)
>>> l1
[0]

當您下次在呼叫 append 函式時，您將看到您使用的先前值附加到空串列引數，

// 第二次呼叫
>>> l2 = append(1)
>>> l2
[0, 1]

簡而言之也就是說由于 l 在 append 函式中被默認初始化為一個 list，第二次呼叫時，l 并沒有重置，導致回傳時還帶有第一次呼叫的結果，

這個問題可以通過重寫代碼來解決，

>>> def append(n, l = None):
...     if l is None:
...         l = []
...     l.append(n)
...     return l
...
>>> l1 = append = [0]
>>> l2 = append = [1]
>>> l1,l2
([0], [1])

現在引數 l 被設定為 None，任何時候函式被呼叫，即使 l 發生了變化，它也會被重新分配為 None，然后給出一個空串列的值，

三、不使用推導式

Python 推導式為您提供了一種構建序列的簡潔方式，上次我檢查過，Python 支持 4 種型別的推導式；

串列推導式
集體推導式
字典推導式
生成器推導式

你可以在這里閱讀更多關于他們的資訊，

下面的代碼將字典中的值除以 2，

>>> numbers = {}
>>> for i in range(10):
...     numbers[i] = i/2
...
>>> numbers
{0: 0.0, 1: 0.5, 2: 1.0, 3: 1.5, 4: 2.0, 5: 2.5, 6: 3.0, 7: 
3.5, 8: 4.0, 9: 4.5}

上面的代碼可以寫成一行，

>>> {i: i/2 for i in range(10)}
{0: 0.0, 1: 0.5, 2: 1.0, 3: 1.5, 4: 2.0, 5: 2.5, 6: 3.0, 7: 
3.5, 8: 4.0, 9: 4.5}

所以不要讓自己過得不好，開始使用推導式，

推導式確實算是 python 開發一大利器，用好推導式，早下班！

四、檢查 Equality 而不是 Identity

如下,

a = [1, 2, 3]
b = [1, 2, 3]

如果我讓你檢查這兩個變數是否相同，你首先想到的是，

>>> a == b
True

問題是你需要知道 Identity 和 Equality 之間的區別，

如果檢查a和b的記憶體地址，

>>> id(a), id(b)
(1838093945856, 1838093487488)

您可以看到盡管它們具有相同的物件，但它們都有不同的記憶體地址，

這就是為什么當你運行代碼時，

>>> a == b
True
You get True, but when you run

>>> a is b
False

當你呼叫 a is b 回傳 False時，a 和 b 就不是相等的了，

在運行如下代碼，

>>> c = [1,2,3]
>>> d = c
>>> id(c), id(d)
(1838089019712, 1838089019712)

可以看到，c和d是相等且相同的，c中的物件也被賦值給了d，

>>> c == d
True
>>> c is d
True

這意味著 c 和 d 具有相同的值和記憶體地址，

因此你可以說 c 是相同的并且等于 d，

寫這篇文章就是為了讓你知道 is 和 == 的區別，前者是用來檢查 identity ，后者是用來檢查 equality 的，

所有相同的變數都相等，但并非所有相等的變數都相同，

這一段看著有點繞，說人話就是 == 比較的是連個變數的值是否相等，is 比較的是兩個比變數的記憶體地址相等!，我相信大伙都明白哈，不然白看了這么多年八股文，

五、不使用元組解包

任何時候你在 Python 中創建一個元組 a_tuple = 1,2,3 ，它會默認進行元組打包，

>>> a_tuple = 1,2,3
>>> a_tuple
(1, 2, 3)

然后可以通過索引訪問元組內元素

>>> x = a_tuple[0]
>>> y = a_tuple[1]
>>> z = a_tuple[2]
>>> print(x, y, z)
1, 2, 3

其實無需使用多行代碼訪問元組中的元素，您可以通過元組解包自動在一行代碼中完成，

>>> x,y,z = a_tuple
>>> print(x, y, z)
1, 2, 3

元組解包也是 python 中常用的開發技巧，提升開發效率，

六、創建您自己的索引計數器變數

這個在其他編程語言中很常見，你被要求創建一個索引計數器變數，然后你輸入類似的東西；

>>> a_list = [1,2,3,4,5,6,7,8,9,10]
>>> index = 0
>>> for elem in a_list:
...     print(index, elem)
...     index += 1
...
0 1
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10

相反，使用 enumerate 函式使您的代碼看起來像 Pythonic（這里指寫出python風格的代碼）；

>>> for index, elem in enumerate(a_list):
...     print(index, elem)
...
0 1
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10

這里批評下 Java，這么多年了，foreach 回圈也拿不到索引，

七、使用 Print 陳述句代替日志記錄模塊

這在小型專案中可能無關緊要，但肯定會對大型專案有所幫助，

不要用列印陳述句亂扔代碼，而是使用日志記錄，

>>> print('This is a warning message')
This is a warning message
>>> print('This is an error message')
This is an error message
>>> print('This is a critical message')
This is a critical message

日志記錄有助于向您的用戶顯示有用的訊息，以增加對代碼庫中發生的事情的更多背景關系和理解，

>>> import logging
>>> logging.warning('This is a warning message')
WARNING:root:This is a warning message
>>> logging.error('This is an error message')
ERROR:root:This is an error message
>>> logging.critical('This is a critical message')
CRITICAL:root:This is a critical message

這年頭還有人在線上不用檔案記錄日志嗎？有的話告訴我一聲，
我肯定拿刀找他!

八、使用 import * 在命名模塊中匯入函式和類

這種壞習慣有時在新手中很常見，

使用 import * 匯入會破壞您的命名空間，方法是將該命名模塊中的所有函式和類匯入您的代碼，這可能會與您定義的函式或匯入的其他庫的函式發生沖突，

反正博主從來不用 import *，至于你用不用我不知道，但是我建議你不要用，

九、不關注 pep8

pep8就是Python官方指定的編碼規范

我們大多數人都犯了這個罪，

我承認我有罪

在我被取消之前??，我知道我在這篇文章中的一些代碼可能違反了 PEP-8 的規則，但事實是痛苦的，需要被告知，遵循 PEP-8 風格和指南讓其他人更容易閱讀并理解你的代碼，

老外的這篇文章在 medium 的郵件推薦中，可能老外知道自己這篇文章的示例代碼也違反了 pep8 規范，怕被取消推薦了，我猜的，不保真，

不推薦

>>> def function():
...     x = [1,2,3]
...     y= [2,3,5]
...     z = [1, 2,3]
...
>>> def value(x = 7):
...     ...
...

你做的 9 件事表明你不是專業的 Python 開發人員