pythonifin太慢
㈠ python有什麼缺點呢
1. - 運行速度慢，因為Python是解釋型語言，是一種高級語言，代碼會在執行的時候，一行一行的使用解釋器翻譯成底層代碼，翻譯成機器碼，而這個過程非常耗時，所以他運行過程中，比很多語言的代碼都慢了很多。
- 線程不能利用多CPU，這是Python最大的確定，GIL即全局解釋器鎖（Global Interpreter Lock），是計算機程序設計語言解釋器用於同步線程的工具，使得任何時刻僅有一個線程在執行，Python的線程是操作系統的原生線程。在Linux上為pthread，在Windows上為Win thread，完全由操作系統調度線程的執行。一個python解釋器進程內有一條主線程，以及多條用戶程序的執行線程。即使在多核CPU平台上，由於GIL的存在，所以禁止多線程的並行執行。
Python的優缺點可以看看傳智播客的社區，裡面很多技術老師寫的相關文章。並且有學習線路圖適合小白學習，每個板塊下面都有配套視頻。
㈡ 提升Python運行速度的5個小技巧
pre{overflow-x: auto}Python 是世界上使用最廣泛的編程語言之一。它是一種解釋型高級通用編程語言，具有廣泛的用途，幾乎可以將其用於所有事物。其以簡單的語法、優雅的代碼和豐富的第三方庫而聞名。python除了有很多優點外，但在速度上還有一個非常大的缺點。
雖然Python代碼運行緩慢，但可以通過下面分享的5個小技巧提升Python運行速度！
首先，定義一個計時函數timeshow，通過簡單的裝飾，可以列印指定函數的運行時間。
這個函數在下面的例子中會被多次使用。
def timeshow(func): from time import time def newfunc(*arg, **kw): t1 = time() res = func(*arg, **kw) t2 = time() print(f"{func.__name__: >10} : {t2-t1:.6f} sec") return res return newfunc @timeshow def test_it(): print("hello pytip") test_it() 1. 選擇合適的數據結構使用正確的數據結構對python腳本的運行時間有顯著影響。Python 有四種內置的數據結構：
列表 : List
元組 : Tuple
集合 : Set
字典 : Dictionary
但是，大多數開發人員在所有情況下都使用列表。這是不正確的做法，應該根據任務使用合適數據結構。
運行下面的代碼，可以看到元組執行簡單檢索操作的速度比列錶快。其中dis模塊反匯編了一個函數的位元組碼，這有利於查看列表和元組之間的區別。
import dis def a(): data = [1, 2, 3, 4, 5,6,7,8,9,10] x =data[5] return x def b(): data = (1, 2, 3, 4, 5,6,7,8,9,10) x =data[5] return x print("-----:使用列表的機器碼:------") dis.dis(a) print("-----:使用元組的機器碼:------") dis.dis(b)運行輸出:
-----:使用列表的機器碼:------
3 0 LOAD_CONST 1 (1)
2 LOAD_CONST 2 (2)
4 LOAD_CONST 3 (3)
6 LOAD_CONST 4 (4)
8 LOAD_CONST 5 (5)
10 LOAD_CONST 6 (6)
12 LOAD_CONST 7 (7)
14 LOAD_CONST 8 (8)
16 LOAD_CONST 9 (9)
18 LOAD_CONST 10 (10)
20 BUILD_LIST 10
22 STORE_FAST 0 (data)
4 24 LOAD_FAST 0 (data)
26 LOAD_CONST 5 (5)
28 BINARY_SUBSCR
30 STORE_FAST 1 (x)
5 32 LOAD_FAST 1 (x)
34 RETURN_VALUE
-----:使用元組的機器碼:------
7 0 LOAD_CONST 1 ((1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
2 STORE_FAST 0 (data)
8 4 LOAD_FAST 0 (data)
6 LOAD_CONST 2 (5)
8 BINARY_SUBSCR
10 STORE_FAST 1 (x)
9 12 LOAD_FAST 1 (x)
14 RETURN_VALUE
看下列表的機器碼，冗長而多餘！
2. 善用強大的內置函數和第三方庫如果你正在使用python並且仍在自己編寫一些通用函數(比如加法、減法)，那麼是在侮辱python。 Python有大量的庫和內置函數來幫助你不用編寫這些函數。 如果研究下，那麼你會驚奇地發現幾乎90%的問題已經有第三方包或內置函數來解決。
可以通過訪問官方文檔查看所有內置函數。你也可以在wiki python上找到更多使用內置函數的場景。
比如，現在我們想合並列表中的所有單詞為一個句子，比較法自己編寫和調用庫函數的區別:
# ❌ 正常人能想到的方法 @timeshow def f1(list): s ="" for substring in list: s += substring return s # ✅ pythonic 的方法 @timeshow def f2(list): s = "".join(list) return s l = ["I", "Love", "Python"] * 1000 # 為了看到差異，我們把這個列表放大了 f1(l) f2(l)運行輸出:
f1 : 0.000227 sec
f2 : 0.000031 sec
3. 少用循環
用 列表推導式 代替循環
用 迭代器 代替循環
用 filter() 代替循環
減少循環次數，精確控制，不浪費CPU
## 返回n以內的可以被7整除的所有數字。 # ❌ 正常人能想到的方法: @timeshow def f_loop(n): L=[] for i in range(n): if i % 7 ==0: L.append(i) return L # ✅ 列表推導式 @timeshow def f_list(n): L = [i for i in range(n) if i % 7 == 0] return L # ✅ 迭代器 @timeshow def f_iter(n): L = (i for i in range(n) if i % 7 == 0) return L # ✅ 過濾器 @timeshow def f_filter(n): L = filter(lambda x: x % 7 == 0, range(n)) return L # ✅ 精確控制循環次數 @timeshow def f_mind(n): L = (i*7 for i in range(n//7)) return L n = 1_000_000 f_loop(n) f_list(n) f_iter(n) f_filter(n) f_mind(n)輸出為:
f_loop : 0.083017 sec
f_list : 0.056110 sec
f_iter : 0.000015 sec
f_filter : 0.000003 sec
f_mind : 0.000002 sec
誰快誰慢，一眼便知！
filter 配合 lambda 大法就是屌！！！
4. 避免循環重復計算如果你有一個迭代器，必須用它的元素做一些耗時計算，比如匹配正則表達式。你應該將正則表達式模式定義在循環之外，因為最好只編譯一次模式，而不是在循環的每次迭代中一次又一次地編譯它。
只要有可能，就應該嘗試在循環外進行盡可能多的運算，比如將函數計算分配給局部變數，然後在函數中使用它。
# ❌ 應改避免的方式： @timeshow def f_more(s): import re for i in s: m = re.search(r'a*[a-z]?c', i) # ✅ 更好的方式： @timeshow def f_less(s): import re regex = re.compile(r'a*[a-z]?c') for i in s: m = regex.search(i) s = ["abctestabc"] * 1_000 f_more(s) f_less(s)輸出為:
f_more : 0.001068 sec
f_less : 0.000365 sec
內存佔用是指程序運行時使用的內存量。為了讓Python代碼運行得更快，應該減少程序的內存使用量，即盡量減少變數或對象的數量。
Python 訪問局部變數比全局變數更有效。在有必要之前，應該始終嘗試忽略聲明全局變數。一個在程序中定義過的全局變數會一直存在，直到整個程序編譯完成，所以它一直占據著內存空間。另一方面，局部變數訪問更快，且函數完成後即可回收。因此，使用多個局部變數比使用全局變數會更好。
# ❌ 應該避免的方式： message = "Line1 " message += "Line2 " message += "Line3 " # ✅ 更好的方式： l = ["Line1","Line2","Line3"] message = ' '.join(l) # ❌ 應該避免的方式： x = 5 y = 6 def add(): return x+y add() # ✅ 更好的方式： def add(): x = 5 y = 6 return x+y add()總結
本篇文章就到這里了，希望能夠給你帶來幫助，也希望您能夠多多關注的更多內容!
㈢ pypy在什麼情況下會比CPython慢很多
大量使用eval和exec的時候
經過測試，以下代碼需要大量內存分配和動態執行，cPython的速度是PyPy的大約3倍(僅體現在讀取文件上，cPython大約10秒，PyPy大約35秒)
# coding: utf-8
import sys, gc
from prettytable import PrettyTable
def ginput(statement):
'''
:param str statement:
:return:
'''
return raw_input(statement.decode('utf-8').encode('gbk')).decode('gbk').encode('utf-8')
def gprint(statement):
'''
:param str statement:
:return:
'''
print statement.decode('utf-8').encode('gbk')
def graise(errorinfo):
'''
:param str errorinfo:
:return:
'''
gprint(errorinfo)
ginput('回車退出')
sys.exit(1)
try:
f=open(u'線路路由表.txt','r')
except:
graise('文件 線路路由表.txt 不存在或打不開')
gprint('正在讀取文件，請盡量留出1GB左右空閑內存')
readbuff=f.read()
if readbuff[-1]==' ': # 分片處理，否則600站以上懟上2G的內存，很容易爆掉，1000站懟4G內存也會爆
buffs=readbuff.split(' ')
x=[]
for buff in buffs:
if buff:
x.extend(eval(buff))
gc.collect()
gprint('已經讀取%d座車站'%len(x))
else:
x=eval(readbuff) # type:list
gprint('文件讀取成功')
f.close()
sNums={x[i][0]:i for i in range(len(x))}
noToName={station[0]:station[1] for station in x}
nameToNo={a:b for b,a in noToName.items()}
gc.collect()
def finder(start,end):
try:
try:
start=int(start)
except:
start=nameToNo[start]
assert noToName[start]
try:
end=int(end)
except:
end=nameToNo[end]
end=noToName[end]
except:
gprint('出發地或目的地在線路圖中找不到')
return None
selection=x[sNums[start]]
selRoute=dict(selection[2])
selMap=selection[3]
try:
assert end in selMap
except:
gprint('脫網，出發站點和目的站點之間不可到達')
return None
prevNo=nameToNo[end]
routeMap=[]
while True:
prevName=noToName[prevNo]
routeMap.append((prevNo,noToName[prevNo],selRoute[prevNo])) # 表庫不支持gprint
prevNo=selMap[prevName]
if prevNo==0:
break
routeMap.reverse()
gprint('最短路線方案(未必最省時間)：')
tb=PrettyTable([u'編號',u'站名',u'距離',u'換乘'], encoding='gbk')
tb.align[u'站名']='l'
tb.align[u'編號']='r'
tb.align[u'距離']='r'
tb.align[u'換乘']='l'
tb.padding_width=2
buff=0
times=0
for route in routeMap:
if buff!=route[0]//100:
buff=route[0]//100
if times!=0 and times!=len(routeMap)-1:
hc=u'%d號線'%buff
else:
hc=''
else:
hc=''
tb.add_row([route[0],route[1].decode('utf-8'),route[2],hc])
times=times+1
print(tb.get_string())
while True:
start=ginput('請輸入您的出發地(車站名或車站編號)，退出請直接關閉程序 ')
end=ginput('請輸入您的目的地(車站名或車站編號) ')
finder(start,end)
以上代碼，其中打開的文件約30M，包括三行，每一行都是一個巨型列表
而PyPy快是很多情況下存在的，以下代碼包含大量計算，PyPy則比cPython快7倍，PyPy執行約40多秒，cPython執行約300多秒
# coding: utf-8
import xlrd, xlwt, time
from sys import exit
from xlutils. import as xl
w=raw_input(u'請輸入您文件所在的路徑，例如 f:\線路信息.xls，當前目錄則不用寫路徑，可以嘗試不寫後綴 '.encode('gbk')).decode('gbk')
start=time.time()
def gprint(statement):
print str(statement).decode('utf-8').encode('gbk')
if u'.' not in w:
w=w+'.xls'
assert w[-4:]==u'.xls', u'只支持xls結尾格式的文件'.encode('gbk')
try:
bk=xlrd.open_workbook(w)
except:
gprint('文件找不到')
exit(1)
st=bk.sheet_by_name(u'時刻表')
endcol=st.ncols
used=[ x for x in range(0,endcol,5) if u'快線' not in st.cell_value(0,x) ] # used columns
lineMap=[]
stNo=lambda station:station[0]
stName=lambda station:station[1]
stDist=lambda station:station[2]
stTrans=lambda station:station[3]
for x in used:
line=[ (int(st.cell_value(y,x)+0.5),st.cell_value(y,x+1).encode('utf-8'),int(st.cell_value(y,x+2)+0.5),[]) for y in range(4,64) if st.cell_value(y,x)!='' ]
lineMap.append(tuple(line))
for line in lineMap:
for station in line:
[ station[3].append(aStation[0]) for aLine in lineMap for aStation in aLine if aStation[1]==station[1] and aStation[0]!=station[0] ]
keyLineMap={line[0][0]//100:line for line in lineMap}
# can pass
feihuancheng=[ station[1] for line in lineMap for station in line if not station[3] ]
huanchengzhan={ station[1] for line in lineMap for station in line if station[3] }
gprint('發現換乘站%d座'%(len(huanchengzhan)))
gprint('線網共有車站%d座'%(len(huanchengzhan)+len(feihuancheng)))
# could pass
zongzhan=[ station[0] for line in lineMap for station in line ]
gprint('重復計入換乘站，一共有%d座車站'%(len(zongzhan)))
def findTransfer(station,distance):
# find all transfers connect to this station, append to a list together
li=[(station[0],distance)]
li.extend([(x,distance) for x in station[3]])
return li
def fetchNext(route,keyLineMap,walkedMap):
'''
:param list route:
:param dict keyLineMap:
:param dict walkedMap:
:return list:
'''
def adding(val,stopNo,dist):
if val==None:
return (stopNo,dist)
elif val[1]>dist:
return (stopNo,dist)
else:
return val
temp=None # single (stopNo, dist)
realPrvStNo=0
for prvStNo, prvDist in route:
line=keyLineMap[prvStNo//100]
order=prvStNo%100
if order<len(line):
nextStop=line[order]
if stName(nextStop) not in walkedMap:
buff=temp
temp=adding(temp,stNo(nextStop),prvDist+stDist(nextStop))
if buff!=temp:
found=nextStop
realPrvStNo=prvStNo
if order>1:
prevStop=line[order-2]
if stName(prevStop) not in walkedMap:
buff=temp
temp=adding(temp,stNo(prevStop),prvDist+stDist(line[order-1])) # 本站的距離欄就是上一站到本站的距離
if buff!=temp:
found=prevStop
realPrvStNo=prvStNo
if temp:
temp=(stName(found),findTransfer(found,temp[1]),realPrvStNo)
return temp
routes=[]
names={}
maxDist=0
walkMaps=[]
for line in lineMap:
gprint('當前處理到%d號線'%(line[0][0]//100))
for station in line:
stationName=stName(station)
if stationName in names.keys():
route=routes[names[stationName]][2]
walkedMap=walkMaps[names[stationName]]
else:
route=findTransfer(station,0)
walkedMap={stationName:0} # 結構為{站名:上一站編號}
while True:
nextStation=fetchNext(route,keyLineMap,walkedMap)
if nextStation:
walkedMap[nextStation[0]]=nextStation[2]
route.extend(nextStation[1])
else:
break
if route[-1][1]>maxDist:
maxDist=route[-1][1]
maxSt=stationName
routes.append((stNo(station),stationName,route))
walkMaps.append(walkedMap)
names[stationName]=len(routes)-1
gprint('全線網最大乘距：%d'%maxDist)
pj=bk.sheet_by_name(u'票價方案')
x=1
pjb=[]
while True:
price=pj.cell_value(x,1)
if price=='':
break
pjb.append((int(price+0.5),int(pj.cell_value(x,0)+0.5)*1000))
x=x+1
assert maxDist<=pjb[-1][1], u'線網最大站距超過最高票價范圍'.encode('gbk')
bback=xl(bk) # type: xlwt.Workbook
pjSheets=[x.name for x in bk.sheets() if u'號線' in x.name]
bk.release_resources()
hrange=lambda x,y:range(x,y+1) # 僅用於rangeMap的計算
findLine=lambda lineNo,rangeDict: [k for k,v in rangeDict.items() if lineNo in v][0] # 給定int型線路號，返回線路所在的表名
rangeMap={x:eval("hrange("+str(x[:-2]).replace('-',',')+")") for x in pjSheets }
findRow=lambda stationNo: zongzhan.index(stationNo)+2 # 返回車站所在的行號(0開始)
def lookup(distance):
'''
:param int distance:
:return int pr: 由距離(米)算出票價
'''
for pr,di in pjb:
if distance<=di:
break
return pr
namebuffer=''
for routeNo, routeName, route in routes:
if routeNo%100==1:
line=routeNo//100
sname=findLine(line,rangeMap)
if namebuffer!=sname: # 換入了下一張表，重置列號
c=2
namebuffer=sname
sheet=bback.get_sheet(sname) # type: xlwt.Worksheet
for toStationNo, distance in route:
price=lookup(distance)
place=findRow(toStationNo)
sheet.write(place,c,label=price)
c=c+1
nw=w.replace(u'.xls',u'另存為.xls')
bback.save(nw)
end=time.time()
gprint('文件已經保存： %s'%nw.encode('utf-8'))
gprint('耗時%d秒'%int(end-start))
f=open(u'線路路由表.txt','w')
spl=(len(routes)-1)//400
if spl==0:
f.write(str([(routes[i][0],routes[i][1],routes[i][2],walkMaps[i]) for i in range(len(routes))]).decode('string-escape'))
f.flush()
else:
for ind in range(spl+1): # 居然忘了range不顧尾
segs=routes[400*ind:400*(ind+1)]
walkSegs=walkMaps[400*ind:400*(ind+1)]
gprint('正在寫入片%d，本片區長%d'%(ind,len(segs)))
f.write(str([(segs[i][0],segs[i][1],segs[i][2],walkSegs[i]) for i in range(len(segs))]).decode('string-escape'))
f.write(' ')
f.flush()
f.close()
gprint('最近路線信息已保存至 線路路由表.txt，回車退出')
raw_input('')
㈣ python中從列表中用for循環刪除(remove方法)停用詞特別慢，有快一點的方法嗎
循環刪除，必須用循環語句，而循環語句就那麼幾個！！
㈤ Python3.4 使用if in 結構進行判斷時出現異常結果
importrandom
classRoomTreasure:
deftake_it(self):
count=input("請輸入你要拿走的數量：")
if'全'incountor'都'incount:
dead=Death().ways()
exit(1)
elifint(count)<=10:
print("恭喜你可以安全離開了")
exit(0)
classDeath:
methods=["被機槍殺死","被激光殺死","被毒氣毒死","被炸死"]
defways(self):
a=getattr(Death(),'methods')
print("你%s了。"%a[random.randint(0,len(a)-1)])
RoomTreasure().take_it()
exit(1)
你再試試
㈥ 使用python同步mysql到redis由於數據較多，一條一條讀出來寫到redis太慢，有沒有可以批量操作的。
MYSQL快速同步數據到Redis
舉例場景：存儲游戲玩家的任務數據，游戲伺服器啟動時將mysql中玩家的數據同步到redis中。
從MySQL中將數據導入到Redis的Hash結構中。當然，最直接的做法就是遍歷MySQL數據，一條一條寫入到Redis中。這樣沒什麼錯，但是速度會非常慢。如果能夠想法使得MySQL的查詢輸出數據直接能夠與Redis命令行的輸入數據協議相吻合，可以節省很多消耗和縮短時間。
Mysql資料庫名稱為：GAME_DB, 表結構舉例：
CREATE TABLE TABLE_MISSION (
playerId int(11) unsigned NOT NULL,
missionList varchar(255) NOT NULL,
PRIMARY KEY (playerId)
);
Redis中的數據結構使用哈希表：
鍵KEY為mission, 哈希域為mysql中對應的playerId, 哈希值為mysql中對應的missionList。 數據如下：
[root@iZ23zcsdouzZ ~]# redis-cli
127.0.0.1:6379> hget missions 36598
"{\"10001\":{\"status\":1,\"progress\":0},\"10002\":{\"status\":1,\"progress\":0},\"10003\":{\"status\":1,\"progress\":0},\"10004\":{\"status\":1,\"progress\":0}}"
快速同步方法：
新建一個後綴.sql文件：mysql2redis_mission.sql
內容如下：
SELECT CONCAT(
"*4\r\n",
'$', LENGTH(redis_cmd), '\r\n',
redis_cmd, '\r\n',
'$', LENGTH(redis_key), '\r\n',
redis_key, '\r\n',
'$', LENGTH(hkey), '\r\n',
hkey, '\r\n',
'$', LENGTH(hval), '\r\n',
hval, '\r'
)
FROM (
SELECT
'HSET' as redis_cmd,
'missions' AS redis_key,
playerId AS hkey,
missionList AS hval
FROM TABLE_MISSION
) AS t
創建shell腳本mysql2redis_mission.sh
內容：
mysql GAME_DB --skip-column-names --raw < mission.sql | redis-cli --pipe
Linux系統終端執行該shell腳本或者直接運行該系統命令，即可將mysql資料庫GAME_DB的表TABLE_MISSION數據同步到redis中鍵missions中去。mysql2redis_mission.sql文件就是將mysql數據的輸出數據格式和redis的輸入數據格式協議相匹配，從而大大縮短了同步時間。
經過測試，同樣一份數據通過單條取出修改數據格式同步寫入到redis消耗的時間為5min, 使用上面的sql文件和shell命令，同步完數據僅耗時3s左右。
㈦ python if in 為啥會報錯
看著像openpyxl。沒用過，不過看著你可以換個方式。a3，那個值賦給一個變數，感覺最好string一下，if string(sheet['A3'].value) == '333' ；
如果想的是這個cell裡面是333222這種，你可以用正則表達式搞一下，單純的in後面應該是個可迭代的對象吧。這東西我就知道個皮毛
㈧ 請問大佬們，為什麼我python運行程序特別慢啊，我這個程序怎麼改一下可以運行的更快呢
您好，茫茫人海之中，能為君排憂解難實屬朕的榮幸，在下拙見，若有錯誤，還望見諒！。展開全部
yxhtest7772017-07-18
關注
分享
697 2
python運行速度慢怎麼辦？6個Python性能優化技巧
Python是一門非常酷的語言，因為很少的Python代碼可以在短時間內做很多事情，並且，Python很容易就能支持多任務和多重處理。
Python的批評者聲稱Python性能低效、執行緩慢，但實際上並非如此：嘗試以下6個小技巧，可以加快Python應用程序。
關鍵代碼可以依賴於擴展包
Python使許多編程任務變得簡單，但是對於很關鍵的任務並不總是提供最好的性能。使用C、C++或者機器語言擴展包來執行關鍵任務能極大改善性能。這些包是依賴於平台的，也就是說，你必須使用特定的、與你使用的平台相關的包。簡而言之,該解決方案提供了一些應用程序的可移植性,以換取性能,您可以獲得只有通過直接向底層主機編程。
下面這些擴展包你可以考慮添加到你的個人擴展庫中：
Cython
PyInlne
PyPy
Pyrex
這些包有不同的作用和執行方式。例如，Pyrex 讓Python處理一些內存任務變得簡單高效；PyInline可以直接讓你在Python應用程序中使用C代碼，雖然內聯代碼被單獨編譯，但是如果你能高效的利用C代碼，它可以在同一個地方處理每一件事情。
使用關鍵字排序
有很多古老的Python代碼在執行時將花費額外的時間去創建一個自定義的排序函數。最好的排序方式是使用關鍵字和默認的sort()方法。
優化循環
每一種編程語言都強調循環語句的優化，Python也是一樣的。盡管你可以依賴於豐富的技術讓循環運行的更快，然而，開發者經常忽略的一個方法是避免在循環內部使用點拼接字元串。
使用新版本
任何一個在線上搜索Python資料的人都會發現無數關於Python版本遷移的信息。通常，Python每一個版本都針對之前的一個版本做了優化和改進，以讓Python運行的更快。限制因素是你喜歡的函數庫是否也針對Python的新版本做了改進。
當你使用了新的函數庫，獲得了Python的新版本，你需要保證代碼依然能夠運行，檢查應用，修正差異。然後，如果你僅僅是非常感謝您的耐心觀看，如有幫助請採納，祝生活愉快！謝謝！