Python程序員鮮為人知但你應(yīng)該知道的17個問題
一、不要使用可變對象作為函數(shù)默認(rèn)值
...: def_list.append(value)
...: return def_list
...:
In [2]: my_list = append_to_list(1)
In [3]: my_list
Out[3]: [1]
In [4]: my_other_list = append_to_list(2)
In [5]: my_other_list
Out[5]: [1, 2] # 看到了吧，其實(shí)我們本來只想生成[2] 但是卻把第一次運(yùn)行的效果頁帶了進(jìn)來
In [6]: import time
In [7]: def report_arg(my_default=time.time()):
...: print(my_default)
...:
In [8]: report_arg() # 第一次執(zhí)行
1399562371.32
In [9]: time.sleep(2) # 隔了2秒
In [10]: report_arg()
1399562371.32 # 時間竟然沒有變
這2個例子說明了什么? 字典,集合,列表等等對象是不適合作為函數(shù)默認(rèn)值的. 因?yàn)檫@個默認(rèn)值實(shí)在函數(shù)建立的時候就生成了, 每次調(diào)用都是用了這個對象的”緩存”. 我在上段時間的分享python高級編程也說到了這個問題,這個是實(shí)際開發(fā)遇到的問題，好好檢查你學(xué)過的代碼, 也許只是問題沒有暴露
可以這樣改:
def append_to_list(element, to=None):
if to is None:
to = []
to.append(element)
return to
二、生成器不保留迭代過后的結(jié)果
In [13]: 2 in gen
Out[13]: True
In [14]: 3 in gen
Out[14]: True
In [15]: 1 in gen
Out[15]: False # 1為什么不在gen里面了? 因?yàn)檎{(diào)用1->2,這個時候1已經(jīng)不在迭代器里面了,被按需生成過了
In [20]: gen = (i for i in range(5))
In [21]: a_list = list(gen) # 可以轉(zhuǎn)化成列表，當(dāng)然a_tuple = tuple(gen) 也可以
In [22]: 2 in a_list
Out[22]: True
In [23]: 3 in a_list
Out[23]: True
In [24]: 1 in a_list # 就算循環(huán)過,值還在
Out[24]: True
三、lambda在閉包中會保存局部變量
In [29]: my_list = [lambda: i for i in range(5)]
In [30]: for l in my_list:
....: print(l())
....:
4
4
4
4
4
這個問題還是上面說的python高級編程中說過具體原因. 其實(shí)就是當(dāng)我賦值給my_list的時候,lambda表達(dá)式就執(zhí)行了i會循環(huán),直到 i =4,i會保留
但是可以用生成器
In [31]: my_gen = (lambda: n for n in range(5))
In [32]: for l in my_gen:
....: print(l())
....:
0
1
2
3
4
也可以堅(jiān)持用list：
In [33]: my_list = [lambda x=i: x for i in range(5)] # 看我給每個lambda表達(dá)式賦了默認(rèn)值
In [34]: for l in my_list:
....: print(l())
....:
0
1
2
3
4
有點(diǎn)不好懂是吧,在看看python的另外一個魔法:
In [35]: def groupby(items, size):
....: return zip(*[iter(items)]*size)
....:
In [36]: groupby(range(9), 3)
Out[36]: [(0, 1, 2), (3, 4, 5), (6, 7, 8)]
一個分組的函數(shù),看起來很不好懂,對吧? 我們來解析下這里
In [39]: [iter(items)]*3
Out[39]:
[<listiterator at 0x10e155fd0>,
<listiterator at 0x10e155fd0>,
<listiterator at 0x10e155fd0>] # 看到了吧, 其實(shí)就是把items變成可迭代的, 重復(fù)三回（同一個對象哦）, 但是別忘了,每次都.next(), 所以起到了分組的作用
In [40]: [lambda x=i: x for i in range(5)]
Out[40]:
[<function __main__.<lambda>>,
<function __main__.<lambda>>,
<function __main__.<lambda>>,
<function __main__.<lambda>>,
<function __main__.<lambda>>] # 看懂了嗎?
四、在循環(huán)中修改列表項(xiàng)
In [45]: for i in a:
....: if not i % 2:
....: a.remove(i)
....:
In [46]: a
Out[46]: [1, 3, 5] # 沒有問題
In [50]: b = [2, 4, 5, 6]
In [51]: for i in b:
....: if not i % 2:
....: b.remove(i)
....:
In [52]: b
Out[52]: [4, 5] # 本來我想要的結(jié)果應(yīng)該是去除偶數(shù)的列表
思考一下,為什么 – 是因?yàn)槟銓α斜淼膔emove,影響了它的index
In [53]: b = [2, 4, 5, 6]
In [54]: for index, item in enumerate(b):
....: print(index, item)
....: if not item % 2:
....: b.remove(item)
....:
(0, 2) # 這里沒有問題 2被刪除了
(1, 5) # 因?yàn)?被刪除目前的列表是[4, 5, 6], 所以索引list[1]直接去找5, 忽略了4
(2, 6)
五、IndexError - 列表取值超出了他的索引數(shù)
In [55]: my_list = [1, 2, 3, 4, 5]
In [56]: my_list[5] # 根本沒有這個元素
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-56-037d00de8360> in <module>()
----> 1 my_list[5]
IndexError: list index out of range # 拋異常了
In [57]: my_list[5:] # 但是可以這樣， 一定要注意, 用好了是trick,用錯了就是坑啊
Out[57]: []
六、重用全局變量
In [58]: def my_func():
....: print(var) # 我可以先調(diào)用一個未定義的變量
....:
In [59]: var = 'global' # 后賦值
In [60]: my_func() # 反正只要調(diào)用函數(shù)時候變量被定義了就可以了
global
In [61]: def my_func():
....: var = 'locally changed'
....:
In [62]: var = 'global'
In [63]: my_func()
In [64]: print(var)
global # 局部變量沒有影響到全局變量
In [65]: def my_func():
....: print(var) # 雖然你全局設(shè)置這個變量, 但是局部變量有同名的, python以為你忘了定義本地變量了
....: var = 'locally changed'
....:
In [66]: var = 'global'
In [67]: my_func()
---------------------------------------------------------------------------
UnboundLocalError Traceback (most recent call last)
<ipython-input-67-d82eda95de40> in <module>()
----> 1 my_func()
<ipython-input-65-0ad11d690936> in my_func()
1 def my_func():
----> 2 print(var)
3 var = 'locally changed'
4
UnboundLocalError: local variable 'var' referenced before assignment
In [68]: def my_func():
....: global var # 這個時候得加全局了
....: print(var) # 這樣就能正常使用
....: var = 'locally changed'
....:
In [69]: var = 'global'
In [70]:
In [70]: my_func()
global
In [71]: print(var)
locally changed # 但是使用了global就改變了全局變量
七、拷貝可變對象
In [73]: my_list1
Out[73]: [[1, 2, 3], [1, 2, 3]]
In [74]: my_list1[1][0] = 'a' # 我只修改子列表中的一項(xiàng)
In [75]: my_list1
Out[75]: [['a', 2, 3], ['a', 2, 3]] # 但是都影響到了
In [76]: my_list2 = [[1, 2, 3] for i in range(2)] # 用這種循環(huán)生成不同對象的方法就不影響了
In [77]: my_list2[1][0] = 'a'
In [78]: my_list2
Out[78]: [[1, 2, 3], ['a', 2, 3]]
八、python多繼承(C3)
In [1]: class A(object):
...: def foo(self):
...: print("class A")
...:
In [2]: class B(object):
...: def foo(self):
...: print("class B")
...:
In [3]: class C(A, B):
...: pass
...:
In [4]: C().foo()
class A # 例子很好懂, C繼承了A和B，從左到右,發(fā)現(xiàn)A有foo方法,返回了
看起來都是很簡單, 有次序的從底向上,從前向后找,找到就返回. 再看例子:
In [5]: class A(object):
...: def foo(self):
...: print("class A")
...:
In [6]: class B(A):
...: pass
...:
In [7]: class C(A):
...: def foo(self):
...: print("class C")
...:
In [8]: class D(B,C):
...: pass
...:
In [9]: D().foo()
class C # ? 按道理, 順序是 D->B->A,為什么找到了C哪去了
這也就涉及了MRO(Method Resolution Order):
In [10]: D.__mro__
Out[10]: (__main__.D, __main__.B, __main__.C, __main__.A, object)
簡單的理解其實(shí)就是新式類是廣度優(yōu)先了， D->B, 但是發(fā)現(xiàn)C也是繼承A，就先找C，最后再去找A
九、列表的+和+=, append和extend
('ID:', 4481323592)
In [18]: a_list += [1]
In [19]: print('ID (+=):', id(a_list))
('ID (+=):', 4481323592) # 使用+= 還是在原來的列表上操作
In [20]: a_list = a_list + [2]
In [21]: print('ID (list = list + ...):', id(a_list))
('ID (list = list + ...):', 4481293056) # 簡單的+其實(shí)已經(jīng)改變了原有列表
In [28]: a_list = []
In [29]: id(a_list)
Out[29]: 4481326976
In [30]: a_list.append(1)
In [31]: id(a_list)
Out[31]: 4481326976 # append 是在原有列表添加
In [32]: a_list.extend([2])
In [33]: id(a_list)
Out[33]: 4481326976 # extend 也是在原有列表上添加
十、datetime也有布爾值
這是一個坑
In [34]: import datetime
In [35]: print('"datetime.time(0,0,0)" (Midnight) ->', bool(datetime.time(0,0,0)))
('"datetime.time(0,0,0)" (Midnight) ->', False)
In [36]: print('"datetime.time(1,0,0)" (1 am) ->', bool(datetime.time(1,0,0)))
('"datetime.time(1,0,0)" (1 am) ->', True)
十一、'==' 和 is 的區(qū)別
我的理解是”is”是判斷2個對象的身份, ==是判斷2個對象的值
In [37]: a = 1
In [38]: b = 1
In [39]: print('a is b', bool(a is b))
('a is b', True)
In [40]: c = 999
In [41]: d = 999
In [42]: print('c is d', bool(c is d))
('c is d', False) # 原因是python的內(nèi)存管理,緩存了-5 - 256的對象
In [43]: print('256 is 257-1', 256 is 257-1)
('256 is 257-1', True)
In [44]: print('257 is 258-1', 257 is 258 - 1)
('257 is 258-1', False)
In [45]: print('-5 is -6+1', -5 is -6+1)
('-5 is -6+1', True)
In [46]: print('-7 is -6-1', -7 is -6-1)
('-7 is -6-1', False)
In [47]: a = 'hello world!'
In [48]: b = 'hello world!'
In [49]: print('a is b,', a is b)
('a is b,', False) # 很明顯 他們沒有被緩存,這是2個字段串的對象
In [50]: print('a == b,', a == b)
('a == b,', True) # 但他們的值相同
# But, 有個特例
In [51]: a = float('nan')
In [52]: print('a is a,', a is a)
('a is a,', True)
In [53]: print('a == a,', a == a)
('a == a,', False) # 亮瞎我眼睛了~
十二、淺拷貝和深拷貝
我們在實(shí)際開發(fā)中都可以向?qū)δ沉斜淼膶ο笞鲂薷?但是可能不希望改動原來的列表. 淺拷貝只拷貝父對象，深拷貝還會拷貝對象的內(nèi)部的子對象
In [65]: list1 = [1, 2]
In [66]: list2 = list1 # 就是個引用, 你操作list2,其實(shí)list1的結(jié)果也會變
In [67]: list3 = list1[:]
In [69]: import copy
In [70]: list4 = copy.copy(list1) # 他和list3一樣 都是淺拷貝
In [71]: id(list1), id(list2), id(list3), id(list4)
Out[71]: (4480620232, 4480620232, 4479667880, 4494894720)
In [72]: list2[0] = 3
In [73]: print('list1:', list1)
('list1:', [3, 2])
In [74]: list3[0] = 4
In [75]: list4[1] = 4
In [76]: print('list1:', list1)
('list1:', [3, 2]) # 對list3和list4操作都沒有對list1有影響
# 再看看深拷貝和淺拷貝的區(qū)別
In [88]: from copy import copy, deepcopy
In [89]: list1 = [[1], [2]]
In [90]: list2 = copy(list1) # 還是淺拷貝
In [91]: list3 = deepcopy(list1) # 深拷貝
In [92]: id(list1), id(list2), id(list3)
Out[92]: (4494896592, 4495349160, 4494896088)
In [93]: list2[0][0] = 3
In [94]: print('list1:', list1)
('list1:', [[3], [2]]) # 看到了吧 假如你操作其子對象 還是和引用一樣 影響了源
In [95]: list3[0][0] = 5
In [96]: print('list1:', list1)
('list1:', [[3], [2]]) # 深拷貝就不會影響
十三、bool其實(shí)是int的子類
In [97]: isinstance(True, int)
Out[97]: True
In [98]: True + True
Out[98]: 2
In [99]: 3 * True + True
Out[99]: 4
In [100]: 3 * True - False
Out[100]: 3
In [104]: True << 10
Out[104]: 1024
十五、元組是不是真的不可變?
In [112]: tup[0] += [1]
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-112-d4f292cf35de> in <module>()
----> 1 tup[0] += [1]
TypeError: 'tuple' object does not support item assignment
In [113]: tup
Out[113]: ([1],) # 我靠 又是亮瞎我眼睛,明明拋了異常 還能修改?
In [114]: tup = ([],)
In [115]: tup[0].extend([1])
In [116]: tup[0]
Out[116]: [1] # 好吧,我有點(diǎn)看明白了, 雖然我不能直接操作元組，但是不能阻止我操作元組中可變的子對象(list)
這里有個不錯的解釋Python's += Is Weird, Part II :
In [117]: my_tup = (1,)
In [118]: my_tup += (4,)
In [119]: my_tup = my_tup + (5,)
In [120]: my_tup
Out[120]: (1, 4, 5) # ? 嗯 不是不能操作元組嘛?
In [121]: my_tup = (1,)
In [122]: print(id(my_tup))
4481317904
In [123]: my_tup += (4,)
In [124]: print(id(my_tup))
4480606864 # 操作的不是原來的元組 所以可以
In [125]: my_tup = my_tup + (5,)
In [126]: print(id(my_tup))
4474234912
十六、python沒有私有方法/變量? 但是可以有”偽”的
In [127]: class my_class(object^E):
.....: def public_method(self):
.....: print('Hello public world!')
.....: def __private_method(self): # 私有以雙下劃線開頭
.....: print('Hello private world!')
.....: def call_private_method_in_class(self):
.....: self.__private_method()
In [132]: my_instance = my_class()
In [133]: my_instance.public_method()
Hello public world! # 普通方法
In [134]: my_instance._my_class__private_method()
Hello private world! # 私有的可以加"_ + 類名字 + 私有方法名字”
In [135]: my_instance.call_private_method_in_class()
Hello private world! # 還可以通過類提供的公有接口內(nèi)部訪問
In [136]: my_instance._my_class__private_variable
Out[136]: 1
十七、異常處理加else
In [150]: try:
.....: print('third element:', a_list[2])
.....: except IndexError:
.....: print('raised IndexError')
.....: else:
.....: print('no error in try-block') # 只有在try里面沒有異常的時候才會執(zhí)行else里面的表達(dá)式
.....:
raised IndexError # 拋異常了 沒完全完成
In [153]: i = 0
In [154]: while i < 2:
.....: print(i)
.....: i += 1
.....: else:
.....: print('in else')
.....:
0
1
in else # while也支持哦~
In [155]: i = 0
In [156]: while i < 2:
.....: print(i)
.....: i += 1
.....: break
.....: else:
.....: print('completed while-loop')
.....:
0 # 被break了 沒有完全執(zhí)行完 就不執(zhí)行else里面的了
In [158]: for i in range(2):
.....: print(i)
.....: else:
.....: print('completed for-loop')
.....:
0
1
completed for-loop
In [159]: for i in range(2):
.....: print(i)
.....: break
.....: else:
.....: print('completed for-loop')
.....:
0 # 也是因?yàn)閎reak了
相關(guān)文章
在Django的form中使用CSS進(jìn)行設(shè)計(jì)的方法
這篇文章主要介紹了在Django的form中使用CSS進(jìn)行設(shè)計(jì)的方法,Django是Python重多人氣開發(fā)框架中最為著名的一個,需要的朋友可以參考下2015-07-07
今天小編幫大家簡單介紹下Python的一種數(shù)據(jù)結(jié)構(gòu):?字典，字典是一種可變?nèi)萜髂Ｐ?，且可存儲任意類型對象，它用于存放具有映射關(guān)系的數(shù)據(jù)，這里介紹歸納十個字典的用法技巧，需要的朋友可以參考下2022-01-01
這篇文章主要為大家詳細(xì)介紹了python實(shí)現(xiàn)井字棋游戲的相關(guān)資料，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價(jià)值，感興趣的小伙伴們可以參考一下2016-02-02
Python的條件語句與運(yùn)算符優(yōu)先級詳解
這篇文章主要介紹了Python的條件語句與運(yùn)算符優(yōu)先級,是Python入門學(xué)習(xí)中的基礎(chǔ)知識,需要的朋友可以參考下2015-10-10
python實(shí)現(xiàn)根據(jù)ip地址反向查找主機(jī)名稱的方法
這篇文章主要介紹了python實(shí)現(xiàn)根據(jù)ip地址反向查找主機(jī)名稱的方法,涉及Python使用socket解析IP的相關(guān)技巧,非常具有實(shí)用價(jià)值,需要的朋友可以參考下2015-04-04
Python警察與小偷的實(shí)現(xiàn)之一客戶端與服務(wù)端通信實(shí)例
這篇文章主要介紹了Python警察與小偷的實(shí)現(xiàn)之一客戶端與服務(wù)端通信實(shí)例,并附有難點(diǎn)及易錯點(diǎn)的分析與說明,需要的朋友可以參考下2014-10-10
python編寫函數(shù)注意事項(xiàng)總結(jié)
在本篇文章里小編給大家分享了一篇關(guān)于python編寫函數(shù)注意事項(xiàng)總結(jié)內(nèi)容，有需要的朋友們可以學(xué)習(xí)下。2021-03-03
這篇文章主要介紹了Python專用方法與迭代機(jī)制,包括類的私有方法、專有方法、模塊私有對象、迭代__iter__()方法的對象等,需要的朋友可以參考下2014-09-09
在anaconda中配置graphviz包的詳細(xì)過程
graphviz是貝爾實(shí)驗(yàn)室開發(fā)的一個開源的工具包，它使用一個特定的DSL(領(lǐng)域特定語言):dot作為腳本語言，然后使用布局引擎來解析此腳本，并完成自動布局，這篇文章主要介紹了如何在anaconda中配置graphviz包,需要的朋友可以參考下2023-02-02
python簡單實(shí)現(xiàn)9宮格圖片實(shí)例
在本篇內(nèi)容里小編給各位分享的是一篇關(guān)于python實(shí)現(xiàn)朋友圈中的九宮格圖片的實(shí)例講解，有需要的朋友們可以參考下。2020-09-09