偷偷摘套内射激情视频,久久精品99国产国产精,中文字幕无线乱码人妻,中文在线中文a,性爽19p

Python 程序員最常犯的十個(gè)錯(cuò)誤

開發(fā) 后端
Python是一門強(qiáng)大而又靈活的編程語(yǔ)言,提供的許多編程機(jī)制和范式可以極大地提高工作效率。 但是與任何軟件工具或語(yǔ)言一樣,如果對(duì)該語(yǔ)言的能力理解有限或無(wú)法欣賞,那么有時(shí)候自己反而會(huì)被阻礙,而不是受益了。正如一句諺語(yǔ)所說(shuō),“自以為知道夠 多,但實(shí)則會(huì)給自己或別人帶來(lái)危險(xiǎn)”(knowing enough to be dangerous)。

常見(jiàn)錯(cuò)誤1:錯(cuò)誤地將表達(dá)式作為函數(shù)的默認(rèn)參數(shù)

在Python中,我們可以為函數(shù)的某個(gè)參數(shù)設(shè)置默認(rèn)值,使該參數(shù)成為可選參數(shù)。雖然這是一個(gè)很好的語(yǔ)言特性,但是當(dāng)默認(rèn)值是可變類型時(shí),也會(huì)導(dǎo)致一些令人困惑的情況。我們來(lái)看看下面這個(gè)Python函數(shù)定義:

  1. >>> def foo(bar=[]):        # bar是可選參數(shù),如果沒(méi)有提供bar的值,則默認(rèn)為[], 
  2. ...    bar.append("baz")    # 但是稍后我們會(huì)看到這行代碼會(huì)出現(xiàn)問(wèn)題。 
  3. ...    return bar 

Python程序員常 犯的一個(gè)錯(cuò)誤,就是想當(dāng)然地認(rèn)為:在每次調(diào)用函數(shù)時(shí),如果沒(méi)有為可選參數(shù)傳入值,那么這個(gè)可選參數(shù)就會(huì)被設(shè)置為指定的默認(rèn)值。在上面的代碼中,你們可能覺(jué) 得重復(fù)調(diào)用foo()函數(shù)應(yīng)該會(huì)一直返回’baz’,因?yàn)槟銈兡J(rèn)每次foo()函數(shù)執(zhí)行時(shí)(沒(méi)有指定bar變量的值),bar變量都被設(shè)置為[](也就 是,一個(gè)新的空列表)。

[[158995]]

但是,實(shí)際運(yùn)行結(jié)果卻是這樣的:

  1. >>> foo() 
  2. ["baz"
  3. >>> foo() 
  4. ["baz""baz"
  5. >>> foo() 
  6. ["baz""baz""baz"

很奇怪吧?為什么每次調(diào)用foo()函數(shù)時(shí),都會(huì)把”baz”這個(gè)默認(rèn)值添加到已有的列表中,而不是重新創(chuàng)建一個(gè)新的空列表呢?

答案就是,可選參數(shù)默認(rèn)值的設(shè)置在Python中只會(huì)被執(zhí)行一次,也就是定義該函數(shù)的時(shí)候。因此,只有當(dāng)foo()函數(shù)被定義時(shí),bar參數(shù)才會(huì)被初始化為默認(rèn)值(也就是,一個(gè)空列表),但是之后每次foo()函數(shù)被調(diào)用時(shí),都會(huì)繼續(xù)使用bar參數(shù)原先初始化生成的那個(gè)列表。

當(dāng)然,一個(gè)常見(jiàn)的解決辦法就是:

  1. >>> def foo(bar=None): 
  2. ...    if bar is None:    # or if not bar: 
  3. ...        bar = [] 
  4. ...    bar.append("baz"
  5. ...    return bar 
  6. ... 
  7. >>> foo() 
  8. ["baz"
  9. >>> foo() 
  10. ["baz"
  11. >>> foo() 
  12. ["baz"

常見(jiàn)問(wèn)題2:錯(cuò)誤地使用類變量

我們來(lái)看下面這個(gè)例子:

  1. >>> class A(object): 
  2. ...     x = 1 
  3. ... 
  4. >>> class B(A): 
  5. ...     pass 
  6. ... 
  7. >>> class C(A): 
  8. ...     pass 
  9. ... 
  10. >>> print A.x, B.x, C.x 
  11. 1 1 1 

這個(gè)結(jié)果很正常。

  1. >>> B.x = 2 
  2. >>> print A.x, B.x, C.x 
  3. 1 2 1 

嗯,結(jié)果和預(yù)計(jì)的一樣。

  1. >>> A.x = 3 
  2. >>> print A.x, B.x, C.x 
  3. 3 2 3 

在Python語(yǔ)言中,類變量是以字典的形式進(jìn)行處理的,并且遵循方法解析順序(Method Resolution Order,MRO)。因此,在上面的代碼中,由于類C中并沒(méi)有x這個(gè)屬性,解釋器將會(huì)查找它的基類(base class,盡管Python支持多重繼承,但是在這個(gè)例子中,C的基類只有A)。換句話說(shuō),C并不沒(méi)有獨(dú)立于A、真正屬于自己的x屬性。所以,引用 C.x實(shí)際上就是引用了A.x。如果沒(méi)有處理好這里的關(guān)系,就會(huì)導(dǎo)致示例中出現(xiàn)的這個(gè)問(wèn)題。

常見(jiàn)錯(cuò)誤3:錯(cuò)誤地指定異常代碼塊(exception block)的參數(shù)

請(qǐng)看下面這段代碼:

  1. >>> try
  2. ...     l = ["a""b"
  3. ...     int(l[2]) 
  4. ... except ValueError, IndexError:  # To catch both exceptions, right? 
  5. ...     pass 
  6. ... 
  7. Traceback (most recent call last): 
  8.   File "<stdin>", line 3, in <module> 
  9. IndexError: list index out of range 

這段代碼的問(wèn)題在于,except語(yǔ)句并不支持以這種方式指定異常。在Python 2.x中,需要使用變量e將異常綁定至可選的第二個(gè)參數(shù)中,才能進(jìn)一步查看異常的情況。因此,在上述代碼中,except語(yǔ)句并沒(méi)有捕獲 IndexError異常;而是將出現(xiàn)的異常綁定到了一個(gè)名為IndexError的參數(shù)中。

要想在except語(yǔ)句中正確地捕獲多個(gè)異常,則應(yīng)將***個(gè)參數(shù)指定為元組,然后在元組中寫下希望捕獲的異常類型。另外,為了提高可移植性,請(qǐng)使用as關(guān)鍵詞,Python 2和Python 3均支持這種用法。

  1. >>> try
  2. ...     l = ["a""b"
  3. ...     int(l[2]) 
  4. ... except (ValueError, IndexError) as e:  
  5. ...     pass 
  6. ... 
  7. >>> 

常見(jiàn)錯(cuò)誤4:錯(cuò)誤理解Python中的變量名解析

Python中的變量名解析遵循所謂的LEGB原則,也就是“L:本地作用域;E:上一層結(jié)構(gòu)中def或lambda的本地作用域;G:全局作用 域;B:內(nèi)置作用域”(Local,Enclosing,Global,Builtin),按順序查找??瓷先ナ遣皇呛芎?jiǎn)單?不過(guò),事實(shí)上這個(gè)原則的生效 方式還是有著一些特殊之處。說(shuō)到這點(diǎn),我們就不得不提下面這個(gè)常見(jiàn)的Python編程錯(cuò)誤。請(qǐng)看下面的代碼:

  1. >>> x = 10 
  2. >>> def foo(): 
  3. ...     x += 1 
  4. ...     print x 
  5. ... 
  6. >>> foo() 
  7. Traceback (most recent call last): 
  8.   File "<stdin>", line 1, in <module> 
  9.   File "<stdin>", line 2, in foo 
  10. UnboundLocalError: local variable 'x' referenced before assignment 

出了什么問(wèn)題?

上述錯(cuò)誤的出現(xiàn),是因?yàn)楫?dāng)你在某個(gè)作用域內(nèi)為變量賦值時(shí),該變量被Python解釋器自動(dòng)視作該作用域的本地變量,并會(huì)取代任何上一層作用域中相同名稱的變量。

正是因?yàn)檫@樣,才會(huì)出現(xiàn)一開始好好的代碼,在某個(gè)函數(shù)內(nèi)部添加了一個(gè)賦值語(yǔ)句之后卻出現(xiàn)了UnboundLocalError,難怪會(huì)讓許多人吃驚。

在使用列表時(shí),Python程序員尤其容易陷入這個(gè)圈套。

請(qǐng)看下面這個(gè)代碼示例:

 

  1. >>> lst = [123
  2. >>> def foo1(): 
  3. ...     lst.append(5)   # 這里沒(méi)問(wèn)題 
  4. ... 
  5. >>> foo1() 
  6. >>> lst 
  7. [1235
  8.  
  9. >>> lst = [123
  10. >>> def foo2(): 
  11. ...     lst += [5]      # ... 但這里就不對(duì)了! 
  12. ... 
  13. >>> foo2() 
  14. Traceback (most recent call last): 
  15.   File "<stdin>", line 1, in <module> 
  16.   File "<stdin>", line 2, in foo 
  17. UnboundLocalError: local variable 'lst' referenced before assignment 

呃?為什么函數(shù)foo1運(yùn)行正常,foo2卻出現(xiàn)了錯(cuò)誤?

答案與上一個(gè)示例相同,但是卻更難捉摸清楚。foo1函數(shù)并沒(méi)有為lst變量進(jìn)行賦值,但是foo2卻有賦值。我們知道,lst += [5]只是lst = lst + [5]的簡(jiǎn)寫,從中我們就可以看出,foo2函數(shù)在嘗試為lst賦值(因此,被Python解釋器認(rèn)為是函數(shù)本地作用域的變量)。但是,我們希望為lst 賦的值卻又是基于lst變量本身(這時(shí),也被認(rèn)為是函數(shù)本地作用域內(nèi)的變量),也就是說(shuō)該變量還沒(méi)有被定義。這才出現(xiàn)了錯(cuò)誤。

常見(jiàn)錯(cuò)誤5:在遍歷列表時(shí)更改列表

下面這段代碼的問(wèn)題應(yīng)該算是十分明顯:

  1. >>> odd = lambda x : bool(x % 2
  2. >>> numbers = [n for n in range(10)] 
  3. >>> for i in range(len(numbers)): 
  4. ...     if odd(numbers[i]): 
  5. ...         del numbers[i]  # BAD: Deleting item from a list while iterating over it 
  6. ... 
  7. Traceback (most recent call last): 
  8.       File "<stdin>", line 2, in <module> 
  9. IndexError: list index out of range 

在遍歷列表或數(shù)組的同時(shí)從中刪除元素,是任何經(jīng)驗(yàn)豐富的Python開發(fā)人員都會(huì)注意的問(wèn)題。但是盡管上面的示例十分明顯,資深開發(fā)人員在編寫更為復(fù)雜代碼的時(shí)候,也很可能會(huì)無(wú)意之下犯同樣的錯(cuò)誤。

幸運(yùn)的是,Python語(yǔ)言融合了許多優(yōu)雅的編程范式,如果使用得當(dāng),可以極大地簡(jiǎn)化代碼。簡(jiǎn)化代碼還有一個(gè)好處,就是不容易出現(xiàn)在遍歷列表時(shí)刪除 元素這個(gè)錯(cuò)誤。能夠做到這點(diǎn)的一個(gè)編程范式就是列表解析式。而且,列表解析式在避免這個(gè)問(wèn)題方面尤其有用,下面用列表解析式重新實(shí)現(xiàn)上面代碼的功能:

  1. >>> odd = lambda x : bool(x % 2
  2. >>> numbers = [n for n in range(10)] 
  3. >>> numbers[:] = [n for n in numbers if not odd(n)]  # ahh, the beauty of it all 
  4. >>> numbers 
  5. [02468

常見(jiàn)錯(cuò)誤6:不理解Python在閉包中如何綁定變量

請(qǐng)看下面這段代碼:

  1. >>> def create_multipliers(): 
  2. ...     return [lambda x : i * x for i in range(5)] 
  3. >>> for multiplier in create_multipliers(): 
  4. ...     print multiplier(2
  5. ... 

你可能覺(jué)得輸出結(jié)果應(yīng)該是這樣的:

0
2
4
6
8

但是,實(shí)際的輸出結(jié)果卻是:

8
8
8
8
8

嚇了一跳吧!

這個(gè)結(jié)果的出現(xiàn),主要是因?yàn)镻ython中的遲綁定(late binding)機(jī)制,即閉包中變量的值只有在內(nèi)部函數(shù)被調(diào)用時(shí)才會(huì)進(jìn)行查詢。因此,在上面的代碼中,每次create_multipliers()所返 回的函數(shù)被調(diào)用時(shí),都會(huì)在附近的作用域中查詢變量i的值(而到那時(shí),循環(huán)已經(jīng)結(jié)束,所以變量i***被賦予的值為4)。

要解決這個(gè)常見(jiàn)Python問(wèn)題的方法中,需要使用一些hack技巧:

  1. >>> def create_multipliers(): 
  2. ...     return [lambda x, i=i : i * x for i in range(5)] 
  3. ... 
  4. >>> for multiplier in create_multipliers(): 
  5. ...     print multiplier(2
  6. ... 
  7. 0 
  8. 2 
  9. 4 
  10. 6 
  11. 8 

請(qǐng)注意!我們?cè)谶@里利用了默認(rèn)參數(shù)來(lái)實(shí)現(xiàn)這個(gè)lambda匿名函數(shù)。有人可能認(rèn)為這樣做很優(yōu)雅,有人會(huì)覺(jué)得很巧妙,還有人會(huì)嗤之以鼻。但是,如果你是一名Python程序員,不管怎樣你都應(yīng)該要了解這種解決方法。

常見(jiàn)錯(cuò)誤7:模塊之間出現(xiàn)循環(huán)依賴(circular dependencies)

假設(shè)你有兩個(gè)文件,分別是a.py和b.py,二者相互引用,如下所示:

a.py文件中的代碼:

 

  1. import b 
  2.  
  3. def f(): 
  4.     return b.x 
  5.  
  6. print f() 

b.py文件中的代碼:

 

  1. import a 
  2.  
  3. x = 1 
  4.  
  5. def g(): 
  6.     print a.f() 

首先,我們嘗試導(dǎo)入a.py模塊:

>>> import a
1

代碼運(yùn)行正常。也許這出乎了你的意料。畢竟,我們這里存在循環(huán)引用這個(gè)問(wèn)題,想必應(yīng)該是會(huì)出現(xiàn)問(wèn)題的,難道不是嗎?

答案是,僅僅存在循環(huán)引用的情況本身并不會(huì)導(dǎo)致問(wèn)題。如果一個(gè)模塊已經(jīng)被引用了,Python可以做到不再次進(jìn)行引用。但是如果每個(gè)模塊試圖訪問(wèn)其他模塊定義的函數(shù)或變量的時(shí)機(jī)不對(duì),那么你就很可能陷入困境。

那么回到我們的示例,當(dāng)我們導(dǎo)入a.py模塊時(shí),它在引用b.py模塊時(shí)是不會(huì)出現(xiàn)問(wèn)題的,因?yàn)閎.py模塊在被引用時(shí),并不需要訪問(wèn)在a.py模 塊中定義的任何變量或函數(shù)。b.py模塊中對(duì)a模塊唯一的引用,就是調(diào)用了a模塊的foo()函數(shù)。但是那個(gè)函數(shù)調(diào)用發(fā)生在g()函數(shù)當(dāng)中,而a.py或 b.py模塊中都沒(méi)有調(diào)用g()函數(shù)。所以,不會(huì)出現(xiàn)問(wèn)題。

但是,如果我們?cè)囍鴮?dǎo)入b.py模塊呢(即之前沒(méi)有引用a.py模塊的前提下):

  1. >>> import b 
  2. Traceback (most recent call last): 
  3.       File "<stdin>", line 1, in <module> 
  4.       File "b.py", line 1, in <module> 
  5.     import a 
  6.       File "a.py", line 6, in <module> 
  7.   print f() 
  8.       File "a.py", line 4, in f 
  9.   return b.x 
  10. AttributeError: 'module' object has no attribute 'x' 

糟糕。情況不太妙!這里的問(wèn)題是,在導(dǎo)入b.py的過(guò)程中,它試圖引用a.py模塊,而a.py模塊接著又要調(diào)用foo()函數(shù),這個(gè)foo()函數(shù)接著又試圖去訪問(wèn)b.x變量。但是這個(gè)時(shí)候,b.x變量還沒(méi)有被定義,所以才出現(xiàn)了AttributeError異常。

解決這個(gè)問(wèn)題有一種非常簡(jiǎn)單的方法,就是簡(jiǎn)單地修改下b.py模塊,在g()函數(shù)內(nèi)部才引用a.py:

 

  1. x = 1 
  2.  
  3. def g(): 
  4.     import a  # This will be evaluated only when g() is called 
  5.     print a.f() 

現(xiàn)在我們?cè)賹?dǎo)入b.py模塊的話,就不會(huì)出現(xiàn)任何問(wèn)題了:

  1. >>> import b 
  2. >>> b.g() 
  3. 1 # Printed a first time since module 'a' calls 'print f()' at the end 
  4. 1 # Printed a second time, this one is our call to 'g' 

常見(jiàn)錯(cuò)誤8:模塊命名與Python標(biāo)準(zhǔn)庫(kù)模塊名沖突

Python語(yǔ)言的一大優(yōu)勢(shì),就是其本身自帶的強(qiáng)大標(biāo)準(zhǔn)庫(kù)。但是,正因?yàn)槿绱耍绻悴蝗タ桃庾⒁獾脑?,你也是有可能為自己的模塊取一個(gè)和 Python自帶標(biāo)準(zhǔn)庫(kù)模塊相同的名字(例如,如果你的代碼中有一個(gè)模塊叫email.py,那么這就會(huì)與Python標(biāo)準(zhǔn)庫(kù)中同名的模塊相沖突。)

這很可能會(huì)給你帶來(lái)難纏的問(wèn)題。舉個(gè)例子,在導(dǎo)入模塊A的時(shí)候,假如該模塊A試圖引用Python標(biāo)準(zhǔn)庫(kù)中的模塊B,但卻因?yàn)槟阋呀?jīng)有了一個(gè)同名模塊B,模塊A會(huì)錯(cuò)誤地引用你自己代碼中的模塊B,而不是Python標(biāo)準(zhǔn)庫(kù)中的模塊B。這也是導(dǎo)致一些嚴(yán)重錯(cuò)誤的原因。

因此,Python程序員要格外注意,避免使用與Python標(biāo)準(zhǔn)庫(kù)模塊相同的名稱。畢竟,修改自己模塊的名稱比提出PEP提議修改上游模塊名稱且讓提議通過(guò),要來(lái)得容易的多。

常見(jiàn)錯(cuò)誤9:未能解決Python 2與Python 3之間的差異

假設(shè)有下面這段代碼:

 

  1. import sys 
  2.  
  3. def bar(i): 
  4.     if i == 1
  5.         raise KeyError(1
  6.     if i == 2
  7.         raise ValueError(2
  8.  
  9. def bad(): 
  10.     e = None 
  11.     try
  12.         bar(int(sys.argv[1])) 
  13.     except KeyError as e: 
  14.         print('key error'
  15.     except ValueError as e: 
  16.         print('value error'
  17.     print(e) 
  18.  
  19. bad() 

如果是Python 2,那么代碼運(yùn)行正常:

  1. $ python foo.py 1 
  2. key error 
  3. 1 
  4. $ python foo.py 2 
  5. value error 
  6. 2 

但是現(xiàn)在,我們換成Python 3再運(yùn)行一遍:

  1. $ python3 foo.py 1 
  2. key error 
  3. Traceback (most recent call last): 
  4.   File "foo.py", line 19, in <module> 
  5.     bad() 
  6.   File "foo.py", line 17, in bad 
  7.     print(e) 
  8. UnboundLocalError: local variable 'e' referenced before assignment 

這到底是怎么回事?這里的“問(wèn)題”是,在Python 3中,異常對(duì)象在except代碼塊作用域之外是無(wú)法訪問(wèn)的。(這么設(shè)計(jì)的原因在于,如果不這樣的話,堆棧幀中就會(huì)一直保留它的引用循環(huán),直到垃圾回收器運(yùn)行,將引用從內(nèi)存中清除。)

避免這個(gè)問(wèn)題的一種方法,就是在except代碼塊的作用域之外,維持一個(gè)對(duì)異常對(duì)象的引用(reference),這樣異常對(duì)象就可以訪問(wèn)了。下面這段代碼就使用了這種方法,因此在Python 2和Python 3中的輸出結(jié)果是一致的:

 

  1. import sys 
  2.  
  3. def bar(i): 
  4.     if i == 1
  5.         raise KeyError(1
  6.     if i == 2
  7.         raise ValueError(2
  8.  
  9. def good(): 
  10.     exception = None 
  11.     try
  12.         bar(int(sys.argv[1])) 
  13.     except KeyError as e: 
  14.         exception = e 
  15.         print('key error'
  16.     except ValueError as e: 
  17.         exception = e 
  18.         print('value error'
  19.     print(exception) 
  20.  
  21. good() 

在Python 3下運(yùn)行代碼:

  1. $ python3 foo.py 1 
  2. key error 
  3. 1 
  4. $ python3 foo.py 2 
  5. value error 
  6. 2 

太棒了!

常見(jiàn)錯(cuò)誤10:錯(cuò)誤使用del方法

假設(shè)你在mod.py的文件中編寫了下面的代碼:

 

  1. import foo 
  2.  
  3. class Bar(object): 
  4.         ... 
  5.     def __del__(self): 
  6.         foo.cleanup(self.myhandle) 

之后,你在another_mod.py文件中進(jìn)行如下操作:

  1. import mod 
  2. mybar = mod.Bar() 

如果你運(yùn)行another_mod.py模塊的話,將會(huì)出現(xiàn)AttributeError異常。

為什么?因?yàn)楫?dāng)解釋器結(jié)束運(yùn)行的時(shí)候,該模塊的全局變量都會(huì)被設(shè)置為None。因此,在上述示例中,當(dāng)__del__方法被調(diào)用之前,foo已經(jīng)被設(shè)置成了None。

要想解決這個(gè)有點(diǎn)棘手的Python編程問(wèn)題,其中一個(gè)辦法就是使用atexit.register()方法。這樣的話,當(dāng)你的程序執(zhí)行完成之后(即正常退出程序的情況下),你所指定的處理程序就會(huì)在解釋器關(guān)閉之前運(yùn)行。

應(yīng)用了上面這種方法,修改后的mod.py文件可能會(huì)是這樣子的:

 

  1. import foo 
  2. import atexit 
  3.  
  4. def cleanup(handle): 
  5.     foo.cleanup(handle) 
  6.  
  7. class Bar(object): 
  8.     def __init__(self): 
  9.         ... 
  10.         atexit.register(cleanup, self.myhandle) 

這種實(shí)現(xiàn)支持在程序正常終止時(shí)干凈利落地調(diào)用任何必要的清理功能。很明顯,上述示例中將會(huì)由foo.cleanup函數(shù)來(lái)決定如何處理self.myhandle所綁定的對(duì)象。

綜述

Python是一門強(qiáng)大而又靈活的編程語(yǔ)言,提供的許多編程機(jī)制和范式可以極大地提高工作效率。 但是與任何軟件工具或語(yǔ)言一樣,如果對(duì)該語(yǔ)言的能力理解有限或無(wú)法欣賞,那么有時(shí)候自己反而會(huì)被阻礙,而不是受益了。正如一句諺語(yǔ)所說(shuō),“自以為知道夠 多,但實(shí)則會(huì)給自己或別人帶來(lái)危險(xiǎn)”(knowing enough to be dangerous)。(譯者注:這句諺語(yǔ)的意思是,自以為已經(jīng)對(duì)某件事情了解足夠,但在實(shí)際去執(zhí)行或?qū)嵤r(shí),卻會(huì)給自己和別人帶來(lái)危險(xiǎn)。)

不斷地熟悉Python語(yǔ)言的一些細(xì)微之處,尤其是本文中提到的10大常見(jiàn)錯(cuò)誤,將會(huì)幫助你有效地使用這門語(yǔ)言,同時(shí)也能避免犯一些比較常見(jiàn)的錯(cuò)誤。

責(zé)任編輯:王雪燕 來(lái)源: codingpy
相關(guān)推薦

2014-05-13 13:09:23

Python程序員

2018-09-29 09:34:20

Python錯(cuò)誤初學(xué)

2022-07-22 15:55:32

Python代碼語(yǔ)言

2021-06-04 10:15:17

JavaSQL編程語(yǔ)言

2009-07-22 09:25:19

程序員非技術(shù)

2009-07-09 09:15:22

2015-08-27 16:15:10

程序員面試錯(cuò)誤

2013-07-02 10:01:04

2025-04-07 01:35:00

Go語(yǔ)言程序

2015-10-08 15:57:30

程序員錯(cuò)誤

2021-07-26 10:07:16

勒索軟件惡意軟件安全

2011-07-15 16:06:16

程序員

2010-05-06 10:12:55

2013-01-14 09:11:07

2024-03-20 17:35:42

2009-06-25 10:15:41

糟糕的程序員

2014-09-26 10:13:32

程序員秘密規(guī)則

2015-10-27 10:20:07

WebjQuery視頻插件

2022-01-05 07:07:36

網(wǎng)絡(luò)

2014-10-09 09:29:25

AngularJS
點(diǎn)贊
收藏

51CTO技術(shù)棧公眾號(hào)