python性能

1. 學python電腦性能要求怎樣

python對電腦性能的要求和你的方向與目的有關，大多數情況下，普通的電腦都是可以的。除非需要編寫大規模運算的程序，或吃內存的程序，或使用顯卡運算的程序，需要對應的設備好一點，否則只是學習的話，不需要考慮電腦性能的問題。

2. 如何看待 python 的性能

在這個行業，相信大家不止一個人也不止一次的說過類似的話:"一個成熟的系統不會是由一門語言去包打天下的」。

還有就是python 在企業中可以作為主要使用語言，比如做web開發的公司，為什麼不呢，真正涉及到密集運算的部分很少，我們可以用很多替代方案解決，例如用c重寫那部分，用python粘合，或者是用其他語言重寫，再提供service介面等等，那個不是要命的問題，業務復雜度和需求變更才是要命的，這個小時討論，只有兩個小時編碼，1個小時測試，快速發布到線上所有環境讓用戶使用才是要命的問題，這個時候你跟我扯性能，那不是搞笑嗎？

還有一點是大部分國內的企業用非python是因為能用python真正解決問題的程序員相比之下少一些，這個來自於我們內部的數據統計，我們是做智能招聘的，通過大把（千萬級）的簡歷分析得到的結果。（不是那種學了一段時間python就妄下定義的人），市場的選擇而已，並不能說明問題。

是的，我自己所在的公司就是用python做為主要開發語言，也包括科學計算，海量分析相關的東西，沒見到他們工作時說python性能差，性能差的地方只佔他們工作的百分之幾，換個語言就繞過去了，當然你要說用python去寫游戲客戶端圖像處理那部分那就真的蛋疼了。每種語言都有他合適的應用場景。

3. python：性能差，還會有人用嗎

有的，多數情況性能差點無所謂。
多數PYTHON小程序幾分鍾就寫好了（例如網路爬蟲），哪怕電腦跑半天也沒關系。而性能好的C語言等花幾天寫個同樣功能的程序，性能高到幾秒鍾就運行完成了，但是工作效率更高了嗎，很顯然不是的。

4. Python怎樣做性能測試

利用profile分析相關的獨立模塊,python內置了豐富的性能分析工具，profile，cProfile與hotshot等。其中Profiler是python自帶的一組程序，能夠描述程序運行時候的性能，並提供各種統計幫助用戶定位程序的性能瓶頸。Python標准模塊提供三profilers:cProfile，profile以及hotshot。profile是python的標准庫。可以統計程序里每一個函數的運行時間，並且提供了多樣化的報表。使用profile來分析一個程序很簡單，profile可以直接用python解釋器調用profile模塊來剖分py程序，如在命令行界面輸入如下命令：

5. 如何進行 Python性能分析，你才能如魚得水

importtimedeftimefunc(f):
deff_timer(*args,**kwargs):
start=time.time()
result=f(*args,**kwargs)
end=time.time()
printf.__name__,'took',end-start,'time'
returnresult
returnf_timer
defget_number():
forxinxrange(5000000):
yieldx@timefuncdefexpensive_function():
forxinget_number():
i=x^x^x
return'someresult!'#prints"expensive_functiontook0.72583088875seconds"result=expensive_function()

6. 如何進行python性能分析

在分析python代碼性能瓶頸，但又不想修改源代碼的時候，ipython shell以及第三方庫提供了很多擴展工具，可以不用在代碼裡面加上統計性能的裝飾器，也能很方便直觀的分析代碼性能。

7. Python3有性能上的提升么

#xiaodeng
#python3


#1、編碼方式和性能
'''
1、py3運行效率更快
2、默認源文件編碼ASCII變為UTF-8，以前文件前加入的coding=utf-8不再需要
3、針對unicode的處理有了明顯的改善，效率明顯提升
'''


#2、數據類型和基本運算
'''
1、int和long進行了統一，統一為int
2、True、False、None都是關鍵詞
3、必須以b'...'表示二進制數據，可以使用u'..'表示字元串，不加u也表示字元串
4、移除<>不等號，使用「!=」表示不等號關系
1）2!=3
2）2<>3#出現語法錯誤
5、調整除法符號『/』的用法，只返回浮點數，要返回整數要使用「//」
6、py3運算對數據的類型要求更加的嚴格
'''

deffoo(test=None):
iftestisNone:
print(test)
foo()


print(5/2)#浮點數
print(5//2)#整數
print(1/3)

#4、print和exec用法
'''
1、print是一個函數，不再是一個語句，其中不需要用空格，後面列印的內容需要有括弧括起來
2、exec函數用法發生變化
'''

deffoo():
_local=locals()
exec('a=4',globals(),_local)
a=_local['a']
print(a)
foo()

#5、input、bin、oct和for循環
'''
1、raw_input統一為input
在py2中用法為：
1）a=raw_input('請輸入：')
printa
2）a=input('請輸入：')#接收一個有效的表達式，如：2+3，而不能單獨接收3
printa
2、for循環的變數不再泄露在全局變數中，此bug已修復
1)Python2.7.10(default,May232015,09:40:32)[MSCv.150032bit(Intel)]onwin32
Type"right","credits"or"license()"formoreinformation.
>>>i=8
>>>print[iforiinrange(5)]
[0,1,2,3,4]
>>>printi
#按照道理來講for循環中的i與最外面的i=8的i是不同的，但是這里。。。。。
>>>

2)
i=6
print([iforiinrange(5)])#結果為[0,1,2,3,4]
print(i)#結果i=6
'''
#6、a=input('請輸入:')#這里不再需要一個有效的表達式，他的用法和raw_input相同
#print(a)


#7、range和dict的變化
'''
1、在python2中，range火xrange會創建一個列表。常出現在for循環、字典、列表中，但是py3中xrange改名為range，在python3中使用
使用xrange會觸發錯誤。同時range返回的是可迭代對象而不再是列表形式，要想使range的結果得到一個list數據必須要使用list(range(5))
2、字典內的dict.iterkeys(),dict.itervalues(),dict.iteritems()被keys()andvalues()anditems()所替代
他們的返回結果類似於集的可迭代對象，而不是鍵值對的列表。從而在不進行鍵和值條目復制的情況下就能對其執行set操作

'''

a=range(6)
print(a)#result:range(0,6)對象，不是列表
print(list(a))#result:[0,1,2,3,4,5]
foriinrange(6):
print(i)

#print(xrange(5))#報錯：提示為name"xrange"is'notdefined

#dict案例
d={'name':"iaodeng",'sex':28}
print(d.items())
print(type(d.items()))#<class'dict_items'>
#返回結果dict_items([('name','iaodeng'),('sex',28)])
#這里不再是列表形式
'''
Python2.7.10(default,May232015,09:40:32)[MSCv.150032bit(Intel)]onwin32
Type"right","credits"or"license()"formoreinformation.
>>>d={'name':"iaodeng",'sex':28}
>>>printd
{'name':'iaodeng','sex':28}
>>>printd.items()
[('name','iaodeng'),('sex',28)]
>>>printd.iteritems()#返回一個可迭代對象
<dictionary->
>>>foriind.iteritems():printi
('name','iaodeng')
('sex',28)
>>>
'''
print('xiaodeng:d.keys():',d.keys())#xiaodeng:d.keys():dict_keys(['name','sex'])
print(type(d.keys()))#<class'dict_items'>

#values()同理


print("既然是可迭代對象，那麼還可以進行下面操作")
foriind.items():
print(i)
forkeyind.keys():
print(key)
print("values用法同理")
print('用list將可迭代對象轉化為list數據')
print(list(d.values()))


#7、python3具有單一的str類型，其類型相當於python2的unicode，python3所有的字元串都是unicode
#新增bytes類型
a=b"china"
print(type(a))#<class'bytes'>
#str和tytes對象都可以使用encode和decode來進行轉化
s=a.decode()
print(s)#china字元串類型
s=s.encode()
print(s)#b"china",tytes位元組類型
#8、輸入和輸出
a=open('test.txt','w')
a.write("writeinsomething")
a.close()
b=open("test.txt","r")
print(b.read())#note：注意加括弧
"""
1、如果要對文本執行任何I/O操作，python3會強制用戶使用文本模式，打開文件，如果不想使用默認編碼utf-8
通常需要指明所需的編碼
2、如果對二進制數據進行I/O操作，必須使用二進制模式打開文件或進行讀寫操作
eg：
f=open("test1.txt","wb+")#二進制追加模式
f.write(b"wlovefengmei")#必須加b，以bytes對象的形式進行寫入
f.close()
file=open(filename,mode)
mode:
r:只讀模式
w:只寫，如果文件已存在則會進行覆蓋操作，所以格外小心，如果文件不存在則創建新的文件
a:打開文件用於追加,只寫如果文件不存在則創建
b:二進制，不能單獨使用
經過演變會有很多形式
"""


#9、迭代器
"""
1、range在python3中返回顆迭代對象二不是列表，最大限度節約內存
2、zip(),map(),filter(),key(),value()返回的均是可迭代對象
"""

#10、異常錯誤處理
"""
1、必須使用關鍵詞as,try和exceptNameErrorase語句
2、案例：
python2
try：
something
exceptNameError,err：
printerr

python3
try:
something
exceptNameErroraserr:
print(err)
3、raise觸發語法用法的變化，python3隻接受帶括弧的
1）raiseIOError,"fileerror"#出現語法錯誤
2）raiseIOError("fileerror")
"""

#11、面向對象
"""
1、需要單獨深入學習
"""

#12、模塊的變動

8. 為什麼python性能差

建議，可以學習一下django這樣的網路框架。

9. Python的優勢有哪些

1. 簡單：Python奉行簡潔主義，易於讀寫，它使你能夠專注於解決問題而不是去搞明白語言本身。
2. 免費：Python是開源軟體。這意味著你不用花一分錢便能復制、閱讀、改動它，這也是Python越來越優秀的原因——它是由一群希望看到一個更加優秀的Python的人創造並經常改進著的。
3. 兼容性：Python兼容眾多平台，所以開發者不會遇到使用其他語言時常會遇到的困擾。
4. 面向對象：Python既支持面向過程，也支持面向對象編程。在面向過程編程中，程序員復用代碼，在面向對象編程中，使用基於數據和函數的對象。
5. 豐富的庫：Python標准庫確實很龐大。它可以幫助你處理各種工作，包括正則表達式、文檔生成、單元測試、線程、資料庫、網頁瀏覽器、CGI、FTP、電子郵件、XML、XML-RPC、HTML、WAV文件、密碼系統、GUI(圖形用戶界面)、Tk和其他與系統有關的操作。
6. 規范的代碼：Python採用強制縮進的方式使得代碼具有極佳的可讀性。
7. 可擴展性和可嵌入性。如果你需要你的一段關鍵代碼運行得更快或者希望某些演算法不公開，你可以把你的部分程序用C或C++編寫，然後在你的Python程序中使用它們。你可以把Python嵌入你的C/C++程序，從而向你的程序用戶提供腳本功能。

10. 誰說Python性能差的

[轉載]
最近看到網上有人對比Python，Shell腳本， C++，主要是拿Python性能說事，個人覺得意義不大。
一個語言有什麼性能問題呢，是背後的實現（標准庫，編譯器）決定著一切，就像總有人想對比c++和c的效率一樣。
還有就是，Python總被人叫做是腳本語言，其實腳本更多指的是批處理命令文件，是shell命令的集合，和python完全
不是一個層次。不同的工具所在層次不同，適用的問題也不同。把不同層次上的東西拉到一起做比較，什麼問題也說明不了。
另外，shell就知道fork，你說他還能幹嘛？:-)。
下面先亂侃一通，再以實例探討下Python的性能問題。
首先，Python是一門動態編程語言，主要亮點是可以提高開發應用的效率。 他是和Java，perl，Ruby等語言同類的。
是做系統集成，Web應用等系統的利器，最近在科學計算領域也是大方光彩（numpy, scipy, sci-kit learn）。
和C/Cplusplus基本不是一個層次的開發工具，他們是做底層系統（基礎庫，os，ecos就是c++寫的，還是用在嵌入式系統中）的，
很多庫提供的功能也很基礎。但，你可以為Python寫c或cpp的模塊，提高你的Python系統的整體性能。
其次，Python的主要解釋器CPython是用C語言實現的，不同類型（dict，list）和函數實現的演算法很不同。如果你的系統對性能很敏感，
那必須了解一些內幕，一個函數輸入不同的參數，性能可能相差很大。另外，Python解釋器執行Python代碼時候，大概經歷如下幾個階段：
1) 載入代碼文件 2)翻譯成AST 3)生成bytecode 4)在PVM（python virtual machine)上執行bytecode，PVM實際是一個基於棧的虛擬機。
其中，前3個階段看文件代碼量，一般就ms級別的消耗，如果你不想浪費，可以使用python -O -m py_compile xx.py命令，
將xx.py先編譯為xx.pyo的位元組碼，然後在調用python xx.pyo執行. PVM你可以簡單的想像為一個C語言寫的函數，裡面有一個非常大的switch，
根據不同的bytecode內容，執行不同的動作。比如遇到一個打開文件指令，這個函數就會調用libc的庫函數，執行c語言的打開文件操作。
其實很多操作python bytecode和c語言之間的性能差異很小的，因為Python的很多功能模塊就是直接執行C庫的。
再次，隨著Python的廣泛應用，CPython解釋器的性能問題確實越來越嚴重，特別是數據挖掘，機器學習領域的日趨火熱，其中很多優秀工具的實現
都是用Python來做的。為了解決這個問題，Python社區提出了多種不同的解釋器，比如針對數值計算的numba，用python實現的python解釋器pypy等。
他們的主要目的就是給Python加速，用到的技術有JIT，LLVM。比如numba為python提供了新的decorator，讓python函數能在運行時
通過llvm庫被翻譯成machine code。而CPython的現在主要的目的就變為一個Python解釋器的範本，就是提供一個穩定可靠的功能最全的解釋器實現參考。
另外，如果某個用Python實現的功能模塊的性能很關鍵，你可以把這個模塊先用Cython翻譯成C語言代碼，然後在編譯為可執行程序。當然用Cython，
你也可以在python中更加方便的調用外部C庫，保證整個系統的性能。所以，很多Python系統的執行會越來越快，但並不是Python快了，而是後面的支持
越來越強大了。
最後，Python就是和Java類似的一門語言，不要把他理解為是一種腳本。剛開始把他理解為腳本，可能是因為python提供了一個命令行工具，讓人可以輸入
python代碼，並立刻見到結果。其實，這只不過python給你提供的一個優秀的工具之一而已。Python在各個領域的使用越來越廣泛，開源資源也越來越多：
1. 大規模分布式計算disco，提供和hadoop類似的maprece模型 htt p:/ /discoprojec t.o rg/
2. 科學計算/可視化 numpy,scipy, matplotlib
3. 數據挖掘orange, sci-kit learn scikit-learn.sourceforg e.n et
4. Web開發 django project
所有IT領域，基本都能找到Python的痕跡。
說了這麼多，舉一個文本處理的例子，就是計算文本中第3列數據的和，來看看Python的功力，特別是性能方面的問題，
對比參考就是awk神器，其實拿awk做對比不是很公平，畢竟awk是優化再優化的工具（沒動力看他的實現，我猜的：）），
應該自己寫個c語言版本的。
樣本文件有1000萬行，格式如下：
data.txt:
d0 sp 0
d1 sp 1
d2 sp 2
d3 sp 3
d4 sp 4
d5 sp 5
d6 sp 6
d7 sp 7
d8 sp 8
d9 sp 9
先看awk的結果：
$ time cat data.txt |awk '{ sum+=$3} END {print sum}'
49976634308700
real 0m3.662s
user 0m3.576s
sys 0m0.240s
1000萬行3秒，效率果真高。
再看Python的，我做了四個版本。
Python代碼版本（1）：
import sys
def data_sum():
datasum = 0
for line in sys.stdin:
raw = line.split()
datasum += int(raw[2],10)
print datasum
if __name__ == "__main__":
data_sum()
Python代碼版本（2）：
import sys
def data_sum():
datasum = 0
for line in sys.stdin:
raw = line.split()
datasum += int(raw[2])
print datasum
if __name__ == "__main__":
data_sum()
Python代碼版本（3）：
def data_sum():
datasum = 0
for line in sys.stdin:
datasum += int(『2』，10)
print datasum
if __name__ == "__main__":
data_sum()
Python代碼版本（4）：
import sys
def data_sum():
datasum = 0
for line in sys.stdin:
raw = line.split()
print datasum
if __name__ == "__main__":
data_sum()
版本（1）執行結果：
首先將python代碼編譯成位元組碼，運行看看
$python -O -m py_compile datasum.py
$ time cat data.txt |python datasum.pyo
49976634308700
real 0m7.151s
user 0m7.088s
sys 0m0.192s

再試試直接運行python代碼
$ time cat data.txt |python datasum.py
49976634308700
real 0m7.323s
user 0m7.228s
sys 0m0.212s
兩種方法大概有個毫秒級別的差異，主要消耗在cpython把python代碼翻譯成ast階段，感興趣可以自己編譯一個cpython驗證下。
還有pypy，看看他的JIT和stackless效果如何。
$ time cat data.txt | pypy-c datasum.py
49976634308700
real 0m4.649s
user 0m4.556s
sys 0m0.224s
怎樣？比awk版本就慢了1秒鍾。我已經非常滿意了。下面再試試其他版本，順便看看到底Python慢在了哪裏。
版本（2）：
$ time cat data.txt |python datasum.py
49976634308700
real 0m9.111s
user 0m9.025s
sys 0m0.220s
$ time cat data.txt | pypy-c datasum.py
49976634308700
real 0m4.694s
user 0m4.588s
sys 0m0.248s
版本（2）直接就比版本（1）慢了2秒。就差了一個base參數而已，原因看下Cpython的代碼就清楚了（Python/bltinmole.c）。
加了base的，直接調用： x = PyOS_strtol(s, &end, base);
不加base的，要通過PyNumber_Int等一列內部類型處理函數，最後到達PyOS_strtol。
版本（3）：
$ time cat data.txt |python datasum.py
20000000
real 0m3.127s
user 0m3.044s
sys 0m0.188s

$ time cat data.txt | pypy-c datasum.py
20000000
real 0m2.393s
user 0m2.320s
sys 0m0.196s
版本（4）：
$ time cat data.txt |python datasum.py
0
real 0m3.920s
user 0m3.852s
sys 0m0.180s
$ time cat data.txt | pypy-c datasum.py
0
real 0m3.324s
user 0m3.208s
sys 0m0.252s
通過對比版本（3）和版本（4）可以發現，Python主要慢在了split函數這裏，也就是提取第3列這個動作上。
初步想想，用C語言確實可以做到速度更快，但用Python沒想到什麼好辦法，正則表達式會更慢。
上面都是用Python的解釋器來執行代碼的，下面把版本（1）用Cython編譯成C語言，看看效果如何：
$ cython --embed -o datasum.c datasum.py
$ gcc -o datasum datasum.c -I/usr/include/python2.7 -lpython2.7
$ time cat data.txt |./datasum
49976634308700
real 0m6.332s
user 0m6.272s
sys 0m0.192s
比pypy還是慢了一些，pypy在代碼生成上有些優化，cython基本就是translate。
總結下就是：
Python是快速原型開發的利器，如果你對性能有要求，那麼就用他的各種優化他，Python不會辜負你的。
當你的領導/客戶給你很大的deadline壓力時候，Python就是你的救命草，呵呵。
當然，某些簡單功能，比如本文的例子，用awk就可以了嘛，幹嘛費力氣優化python，:-)。