調用字典python速度太慢

❶ 電腦培訓分享怎樣才能提高python運行效率

python逐漸走入人們的視線，成為熱門編程語言，隨之而來，加入python培訓的准程序員大軍也成為社會熱點。Python具有許多其他編程語言不具備的優勢，譬如能通過極少量代碼完成許多操作，以及多進程，能夠輕松支持多任務處理。除了多種優勢外，python也有不好的地方，運行較慢，下面電腦培訓http://www.kmbdqn.com/為大家介紹6個竅門，可以幫你提高python的運行效率。

1.在排序時使用鍵

Python含有許多古老的排序規則，這些規則在你創建定製的排序方法時會佔用很多時間，而這些排序方法運行時也會拖延程序實際的運行速度。最佳的排序方法其實是盡可能多地使用鍵和內置的sort()方法。

2.交叉編譯你的應用

開發者有時會忘記計算機其實並不理解用來創建現代應用程序的編程語言。計算機理解的是機器語言。為了運行你的應用，你藉助一個應用將你所編的人類可讀的代碼轉換成機器可讀的代碼。有時，你用一種諸如Python這樣的語言編寫應用，再以C++這樣的語言運行你的應用，這在運行的角度來說，是可行的。關鍵在於，你想你的應用完成什麼事情，而你的主機系統能提供什麼樣的資源。

3.關鍵代碼使用外部功能包

Python簡化了許多編程任務，但是對於一些時間敏感的任務，它的表現經常不盡人意。使用C/C++或機器語言的外部功能包處理時間敏感任務，可以有效提高應用的運行效率。這些功能包往往依附於特定的平台，因此你要根據自己所用的平台選擇合適的功能包。簡而言之，這個竅門要你犧牲應用的可移植性以換取只有通過對底層主機的直接編程才能獲得的運行效率。

4.針對循環的優化

每一種編程語言都強調最優化的循環方案。當使用Python時，你可以藉助豐富的技巧讓循環程序跑得更快。然而，開發者們經常遺忘的一個技巧是：盡量避免在循環中訪問變數的屬性。

5.嘗試多種編碼方法

每次創建應用時都使用同一種編碼方法幾乎無一例外會導致應用的運行效率不盡人意。可以在程序分析時嘗試一些試驗性的辦法。譬如說，在處理字典中的數據項時，你既可以使用安全的方法，先確保數據項已經存在再進行更新，也可以直接對數據項進行更新，把不存在的數據項作為特例分開處理。

6.使用較新的Python版本

你要保證自己的代碼在新版本里還能運行。你需要使用新的函數庫才能體驗新的Python版本，然後你需要在做出關鍵性的改動時檢查自己的應用。只有當你完成必要的修正之後，你才能體會新版本的不同。

❷ python中列表比詞典的查找操作插入要慢很多

翻任意一本數據結構和演算法分析的書，裡面都有順序表查找和Hash表查找的例子，以及理論分析。順序表的話平均查找時間為O(n)，hash表查找時間為O(1)。還有插入的時間沒有算在內。

python的字典操作的詳細實現，我查過，在《代碼之美》一書裡面有python的設計人員的詳細分析。我們幾句話講不清楚。
http://book.douban.com/subject/3224524/

還有就是你的程序如果只是希望記錄不重復的單詞，用set對象代碼可以更好看一點。

❸ 請問大佬們，為什麼我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的新版本，你需要保證代碼依然能夠運行，檢查應用，修正差異。然後，如果你僅僅是非常感謝您的耐心觀看，如有幫助請採納，祝生活愉快！謝謝！

❹ python中字典的使用方法怎麼樣的

字典理解如下
另一個非常有用的 Python 內建數據類型是 字典 （參見 Mapping Types — dict ）。字典在某些語言中可能稱為 聯合內存 （ associative memories ）或 聯合數組 （ associative arrays ）。序列是以連續的整數為索引，與此不同的是，字典以 關鍵字 為索引，關鍵字可以是任意不可變類型，通常用字元串或數值。如果元組中只包含字元串和數字，它可以作為關鍵字，如果它直接或間接的包含了可變對象，就不能當作關鍵字。不能用列表做關鍵字，因為列表可以用索引、切割或者 append() 和 extend() 等方法改變。
理解字典的最佳方式是把它看作無序的鍵： 值對 （key:value 對）集合，鍵必須是互不相同的（在同一個字典之內）。一對大括弧創建一個空的字典： {} 。初始化列表時，在大括弧內放置一組逗號分隔的鍵：值對，這也是字典輸出的方式。
字典的主要操作是依據鍵來存儲和析取值。也可以用 del 來刪除鍵：值對（key:value）。如果你用一個已經存在的關鍵字存儲值，以前為該關鍵字分配的值就會被遺忘。試圖從一個不存在的鍵中取值會導致錯誤。
對一個字典執行 list(d.keys()) 將返回一個字典中所有關鍵字組成的無序列表（如果你想要排序，只需使用 sorted(d.keys()) ）。[2] 使用 in 關鍵字（指Python語法）可以檢查字典中是否存在某個關鍵字（指字典）。

❺ python 字典為什麼這么快

因為字典是通過鍵來索引的，關聯到相對的值，理論上他的查詢復雜度是O(1)。
哈希表（也叫散列表），根據關鍵值對(Key-value)而直接進行訪問的數據結構。它通過把key和value映射到表中一個位置來訪問記錄，這種查詢速度非常快，更新也快。而這個映射函數叫做哈希函數，存放值的數組叫做哈希表。 哈希函數的實現方式決定了哈希表的搜索效率。

❻ python中字典的使用方法怎麼樣的

dict全稱dictionary，使用鍵-值（key-value）存儲，具有極快的查找速度。
舉個例子，假設要根據同學的名字查找對應的成績，如果用list實現，需要兩個list：
names = ['Michael', 'Bob', 'Tracy']
scores = [95, 75, 85]

給定一個名字，要查找對應的成績，就先要在names中找到對應的位置，再從scores取出對應的成績，list越長，耗時越長。
如果用dict實現，只需要一個「名字」-「成績」的對照表，直接根據名字查找成績，無論這個表有多大，查找速度都不會變慢。用Python寫一個dict如下：
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95

把數據放入dict的方法，除了初始化時指定外，還可以通過key放入：
>>> d['Adam'] = 67
>>> d['Adam']
67

由於一個key只能對應一個value，所以，多次對一個key放入value，後面的值會把前面的值沖掉：
>>> d['Jack'] = 90
>>> d['Jack']
90
>>> d['Jack'] = 88
>>> d['Jack']
88

如果key不存在，dict就會報錯：
>>> d['Thomas']
Traceback (most recent call last):
File "", line 1, in KeyError: 'Thomas'

要避免key不存在的錯誤，有兩種辦法，一是通過in判斷key是否存在：
>>> 'Thomas' in dFalse

二是通過dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value：
>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1
要刪除一個key，用pop(key)方法，對應的value也會從dict中刪除：
>>> d.pop('Bob')
75
>>> d
{'Michael': 95, 'Tracy': 85}

❼ 如何提高python的運行效率

竅門一：關鍵代碼使用外部功能包

Python簡化了許多編程任務，但是對於一些時間敏感的任務，它的表現經常不盡人意。使用C/C++或機器語言的外部功能包處理時間敏感任務，可以有效提高應用的運行效率。這些功能包往往依附於特定的平台，因此你要根據自己所用的平台選擇合適的功能包。簡而言之，這個竅門要你犧牲應用的可移植性以換取只有通過對底層主機的直接編程才能獲得的運行效率。以下是一些你可以選擇用來提升效率的功能包：

Cython
Pylnlne
PyPy
Pyrex

這些功能包的用處各有不同。比如說，使用C語言的數據類型，可以使涉及內存操作的任務更高效或者更直觀。Pyrex就能幫助Python延展出這樣的功能。Pylnline能使你在Python應用中直接使用C代碼。內聯代碼是獨立編譯的，但是它把所有編譯文件都保存在某處，並能充分利用C語言提供的高效率。

竅門二：在排序時使用鍵

Python含有許多古老的排序規則，這些規則在你創建定製的排序方法時會佔用很多時間，而這些排序方法運行時也會拖延程序實際的運行速度。最佳的排序方法其實是盡可能多地使用鍵和內置的sort()方法。譬如，拿下面的代碼來說：

import operator
somelist = [(1, 5,]
在每段例子里，list都是根據你選擇的用作關鍵參數的索引進行排序的。這個方法不僅對數值類型有效，還同樣適用於字元串類型。

竅門三：針對循環的優化

每一種編程語言都強調最優化的循環方案。當使用Python時，你可以藉助豐富的技巧讓循環程序跑得更快。然而，開發者們經常遺忘的一個技巧是：盡量避免在循環中訪問變數的屬性。譬如，拿下面的代碼來說：

lowerlist = ['this', 'is', 'lowercase']
upper = str.upper
upperlist = []
append = upperlist.append
for word in lowerlist:
append(upper(word))
print(upperlist)
#Output = ['THIS', 'IS', 'LOWERCASE']
每次你調用str.upper, Python都會計算這個式子的值。然而，如果你把這個求值賦值給一個變數，那麼求值的結果就能提前知道，Python程序就能運行得更快。因此，關鍵就是盡可能減小Python在循環中的工作量。因為Python解釋執行的特性，在上面的例子中會大大減慢它的速度。

（注意：優化循環的方法還有很多，這只是其中之一。比如，很多程序員會認為，列表推導式是提高循環速度的最佳方法。關鍵在於，優化循環方案是提高應用程序運行速度的上佳選擇。）

竅門四：使用較新的Python版本

如果你在網上搜索Python，你會發現數不盡的信息都是關於如何升級Python版本。通常，每個版本的Python都會包含優化內容，使其運行速度優於之前的版本。但是，限制因素在於，你最喜歡的函數庫有沒有同步更新支持新的Python版本。與其爭論函數庫是否應該更新，關鍵在於新的Python版本是否足夠高效來支持這一更新。

你要保證自己的代碼在新版本里還能運行。你需要使用新的函數庫才能體驗新的Python版本，然後你需要在做出關鍵性的改動時檢查自己的應用。只有當你完成必要的修正之後，你才能體會新版本的不同。

然而，如果你只是確保自己的應用在新版本中可以運行，你很可能會錯過新版本提供的新特性。一旦你決定更新，請分析你的應用在新版本下的表現，並檢查可能出問題的部分，然後優先針對這些部分應用新版本的特性。只有這樣，用戶才能在更新之初就覺察到應用性能的改觀。

竅門五：嘗試多種編碼方法

每次創建應用時都使用同一種編碼方法幾乎無一例外會導致應用的運行效率不盡人意。可以在程序分析時嘗試一些試驗性的辦法。譬如說，在處理字典中的數據項時，你既可以使用安全的方法，先確保數據項已經存在再進行更新，也可以直接對數據項進行更新，把不存在的數據項作為特例分開處理。請看下面第一段代碼：

n = 16
myDict = {}
for i in range(0, n):
char = 'abcd'[i%4]
if char not in myDict:
myDict[char] = 0
myDict[char] += 1
print(myDict)
當一開始myDict為空時，這段代碼會跑得比較快。然而，通常情況下，myDict填滿了數據，至少填有大部分數據，這時換另一種方法會更有效率。

n = 16
myDict = {}
for i in range(0, n):
char = 'abcd'[i%4]
try:
myDict[char] += 1
except KeyError:
myDict[char] = 1
print(myDict)
在兩種方法中輸出結果都是一樣的。區別在於輸出是如何獲得的。跳出常規的思維模式，創建新的編程技巧能使你的應用更有效率。

竅門六：交叉編譯你的應用

開發者有時會忘記計算機其實並不理解用來創建現代應用程序的編程語言。計算機理解的是機器語言。為了運行你的應用，你藉助一個應用將你所編的人類可讀的代碼轉換成機器可讀的代碼。有時，你用一種諸如Python這樣的語言編寫應用，再以C++這樣的語言運行你的應用，這在運行的角度來說，是可行的。關鍵在於，你想你的應用完成什麼事情，而你的主機系統能提供什麼樣的資源。

Nuitka是一款有趣的交叉編譯器，能將你的Python代碼轉化成C++代碼。這樣，你就可以在native模式下執行自己的應用，而無需依賴於解釋器程序。你會發現自己的應用運行效率有了較大的提高，但是這會因平台和任務的差異而有所不同。

（注意：Nuitka現在還處在測試階段，所以在實際應用中請多加註意。實際上，當下最好還是把它用於實驗。此外，關於交叉編譯是否為提高運行效率的最佳方法還存在討論的空間。開發者已經使用交叉編譯多年，用來提高應用的速度。記住，每一種解決辦法都有利有弊，在把它用於生產環境之前請仔細權衡。）

在使用交叉編譯器時，記得確保它支持你所用的Python版本。Nuitka支持Python2.6, 2.7, 3.2和3.3。為了讓解決方案生效，你需要一個Python解釋器和一個C++編譯器。Nuitka支持許多C++編譯器，其中包括Microsoft Visual Studio,MinGW 和 Clang/LLVM。

交叉編譯可能造成一些嚴重問題。比如，在使用Nuitka時，你會發現即便是一個小程序也會消耗巨大的驅動空間。因為Nuitka藉助一系列的動態鏈接庫（DDLs）來執行Python的功能。因此，如果你用的是一個資源很有限的系統，這種方法或許不太可行。

❽ 為什麼我的cmd調用python特別慢，大概有十幾秒時間

1. 直接用滑鼠點python.exe運行怎麼樣呢
   

2. 是不是環境變數太多太多了導致電腦尋找命令過慢

3. 配置怎麼樣噢
   

❾ python測試type函數驗證列表和字典的速度分別是多少

第一段：
if(pos in fre_dist.keys()):
newvalue= fre_dist[pos]

第二段：
if(pos in fre_dist):
newValue=fre_dist[pos]

在處理3萬條數據時，第二段代碼的速度是第一段代碼速度的上千倍。
原因是：第一段代碼 fre_dist.keys()變成了list，python在檢索list的時候是比較慢的，第二段代碼 fre_dist是字典，python在檢索字典的時候速度是比較快的。

❿ 關於中文python打字太慢的問題有人來聊么

說明：增加代碼的描述力，可以成倍減少你的LOC，做到簡單，並且真切有力
觀點：少打字＝多思考＋少出錯，10代碼行比50行更能讓人明白，以下技巧有助於提高5倍工作效率
1. 交換變數值時避免使用臨時變數：(cookbook1.1)
老代碼：我們經常很熟練於下面的代碼
temp = x
x = y
y = temp
代碼一：
u, v, w = w, v, u
有人提出可以利用賦值順序來簡化上面的三行代碼成一行
代碼二：
u, v = v, u
其實利用Python元組賦值的概念，可更簡明 -- 元組初始化 + 元組賦值
2. 讀字典時避免判斷鍵值是否存在：(cookbook1.2)
d = { 'key': 'value' }
老代碼：
if 'key' in d: print d['key']
else: print 'not find'
新代碼：
print d.get('key', 'not find')
3. 尋找最小值和位置的代碼優化：
s = [ 4,1,8,3 ]
老代碼：
mval, mpos = MAX, 0
for i in xrange(len(s)):
if s[i] < mval: mval, mpos = s[i], i
新代碼：
mval, mpos = min([ (s[i], i) for i in xrange(len(s)) ])
元組比較的特性，可以方便的寫做一行
觀點一：用Python編程，需要有「一字千金」的感覺；既然選擇了Python，就不要在意單條語句的效率。
上面幾點例子很基礎，實際中將原始代碼壓縮1/5並不是不可能，我們之前一個子項目，C++代碼270K
重構後Python代碼只有67K，當然使用python的日誌模塊（logging），讀寫表格文本（csv）等，也功
不可末，最終代碼變成原來的1/4，我覺得自己的壽命延長了三倍。。。下面優化幾個常用代碼：

4. 文件讀取工作的最簡單表達：
老代碼：我們需要將文本文件讀入到內存中
line = ''
fp = open('text.txt', 'r')
for line in fp: text += line
代碼一：
text = string.join([ line for line in open('text.txt')], '']
代碼二：
text = ''.join([ line for line in open('text.txt')])
代碼三：
text = file('text.txt').read()
新版本的Python可以讓你寫出比1，2漂亮的代碼（open是file的別名，這里file更直觀）
5. 如何在Python實現三元式：
老代碼：用慣C++,Java,C#不喜歡寫下面代碼
if n >= 0: print 'positive'
else: print 'negitive'
代碼一：該技巧在 Lua里也很常見
print (n >= 0) and 'positive' or 'negitive'
說明：這里的'and'和'or'相當於C中的':'和'?'的作用，道理很簡單，因為如果表達式為
真了那麼後面的or被短路，取到'positive'；否則，and被短路，取到'negitive'
代碼二：
print (n >= 0 and ['positive'] or ['negitive])[0]
說明：將兩個值組裝成元組，即使'positive'是None, '', 0 之類整句話都很安全
代碼三：
print ('negitive', 'positive')[n >= 0]
說明：(FalseValue, TrueValue)[Condition] 是利用了 元組訪問 + True=1 兩條原理
6. 避免字典成員是復雜對象的初始化：(cookbook1.5)
老代碼：
if not y in d: d[y] = { }
d[y][x] = 3
新代碼：
d.setdefault(y, { })[x] = 3
如果成員是列表的話也一樣: d.setdefault(key, []).append(val)
上面六點技巧加以發揮，代碼已經很緊湊了，但是還沒有做到「沒有一句廢話」可能有人懷疑真的能
減少1/5的代碼么？？我要說的是1/5其實很保守，Thinking in C++的作者後來用了Python以後
覺得Python甚至提高了10倍的工作效率。下面的例子可以進一步說明：
例子1：把文本的IP地址轉化為整數
說明：需要將類似'192.168.10.214'的IP地址轉化為 0x0C0A80AD6，在不用 inet_aton情況下
當C++/Java程序員正為如何進行文本分析，處理各種錯誤輸入煩惱時，Python程序員已經下班：
f = lambda ip: sum( [ int(k)*v for k, v in zip(ip.split('.'), [1<<24, 65536, 256, 1])] )
首先ip.split('.')得到列表['192','168','10','214']，經過zip一組裝，就變成
[('192',0x1000000),('168',0x10000),('10',0x100),('214',1)]
接著for循環將各個元組的兩項做整數乘法，最後將新列表的值用sum求和，得到結果
C++程序員不肖道：「你似乎太相信數據了，根本沒有考慮道錯誤的輸入」
Python程序員回答：「外面的try/except已幫我完成所有異常處理，不必擔心越界崩潰而無法捕獲」
Java程序員得意的看著自己百行代碼：「我想知道你如何讓你的同事來理解你的傑作？你有沒有考慮過將
類似gettoken之類的功能獨立處理，讓類似問題可以復用？我的代碼說明了如何充分發揮Reflection和
interface的優秀特性，在增加重用性的同時，提供清晰可讀的代碼」
Python無奈道：「這是『純粹的代碼』，意思是不可修改，類似正則表達式，只要讓人明白他的功能就行了，
要修改就重寫。再我能用三行代碼完成以內絕不會有封裝的想法，況且熟悉Python者也不覺得難讀啊？」
C++程序員拋出殺手簡：「如果讓你一秒鍾處理10w個ip轉化的話怎麼辦？」
Python程序員覺得想睡覺：「你覺得我會蠢到還用Python做這樣的事情么？」
此時C++程序員似乎並沒聽到，反而開始認真的思考起自己剛才提出問題來，一會只見他輕藐的看了另外兩
人一眼，然後胸有成竹的轉到電腦前，開始往屏幕上輸入：「template <....」
小笑話：封裝的陷阱，讓人一邊喊著「封裝」或「復用」，一邊在新項目中，全部打破重寫，並解釋為--重構
觀點二：簡單即是美，把一個東西設計復雜了，本身就是有問題的
思考題：上面的程序，如果反過來，將ip的整數形式轉化為字元串，各位該如何設計呢？？
例子2：輸出一個對象各個成員的名稱和值
g = lambda m: '/n'.join([ '%s=%s'%(k, repr(v)) for k, v in m.__dict__.iteritems() ])
用法：print g(x)
延伸：上面兩個例子熟悉了lambda以後，建議可以嘗試使用下 yield
觀點總結
Q:「怎樣才算做到注重What you think多於What you are writing」
A:「就是說你手上打著第1頁需求的代碼，眼睛卻在看著第2頁需求的內容，心裡想著如何應對5-10頁的東西」
國外多年前廢除PASCAL改用Python做科研教學是有道理的，關於精簡代碼的例子舉不勝舉，用它編碼時應
該有「一字千金」的感覺，否則最終寫出來的，還是「偽裝成Python的C++程序」。
編程本來就是快樂的，避免過多的體力勞動，贏得更多思考的時間。
思考題：到底是封裝呢？還是放棄封裝？
思考題：「more than one way to do it」是不是就是好事？它的反面是什麼？

PS: 更多實用方法可以閱讀 Daily Python URL 以及《Python Cookbook》