1. python中字典的內建函數用法是什麼
字典內置函數&方法
Python字典包含了以下內置函數：
1 cmp(dict1, dict2)
比較兩個字典元素。
2 len(dict)
計算字典元素個數，即鍵的總數。
3 str(dict)
輸出字典可列印的字元串表示。
4 type(variable)
返回輸入的變數類型，如果變數是字典就返回字典類型。
2. Python如何管理內存
Python中的內存管理是從三個方面來進行的,一對象的引用計數機制,二垃圾回收機制,三內存池機制
一、對象的引用計數機制
Python內部使用引用計數，來保持追蹤內存中的對象，所有對象都有引用計數。
引用計數增加的情況：
1，一個對象分配一個新名稱
2，將其放入一個容器中(如列表、元組或字典)
引用計數減少的情況：
1，使用del語句對對象別名顯示的銷毀
2，引用超出作用域或被重新賦值
sys.getrefcount( )函數可以獲得對象的當前引用計數
多數情況下，引用計數比你猜測得要大得多。對於不可變數據(如數字和字元串)，解釋器會在程序的不同部分共享內存，以便節約內存。
二、垃圾回收
1，當一個對象的引用計數歸零時，它將被垃圾收集機制處理掉。
2，當兩個對象a和b相互引用時，del語句可以減少a和b的引用計數，並銷毀用於引用底層對象的名稱。然而由於每個對象都包含一個對其他對象的應用，因此引用計數不會歸零，對象也不會銷毀。(從而導致內存泄露)。為解決這一問題，解釋器會定期執行一個循環檢測器，搜索不可訪問對象的循環並刪除它們。
三、內存池機制
Python提供了對內存的垃圾收集機制，但是它將不用的內存放到內存池而不是返回給操作系統。
1，Pymalloc機制。為了加速Python的執行效率，Python引入了一個內存池機制，用於管理對小塊內存的申請和釋放。
2，Python中所有小於256個位元組的對象都使用pymalloc實現的分配器，而大的對象則使用系統的malloc。
3，對於Python對象，如整數，浮點數和List，都有其獨立的私有內存池，對象間不共享他們的內存池。也就是說如果你分配又釋放了大量的整數，用於緩存這些整數的內存就不能再分配給浮點數。
3. Python如何進行內存管理
Python是如何進行內存管理的？
答:從三個方面來說,一對象的引用計數機制,二垃圾回收機制,三內存池機制。
一、對象的引用計數機制
Python內部使用引用計數，來保持追蹤內存中的對象，所有對象都有引用計數。
引用計數增加的情況：
1，一個對象分配一個新名稱
2，將其放入一個容器中（如列表、元組或字典）
引用計數減少的情況：
1，使用del語句對對象別名顯示的銷毀
2，引用超出作用域或被重新賦值
Sys.getrefcount( )函數可以獲得對象的當前引用計數
多數情況下，引用計數比你猜測得要大得多。對於不可變數據（如數字和字元串），解釋器會在程序的不同部分共享內存，以便節約內存。
相關推薦：《Python視頻教程》
二、垃圾回收
1，當一個對象的引用計數歸零時，它將被垃圾收集機制處理掉。
2，當兩個對象a和b相互引用時，del語句可以減少a和b的引用計數，並銷毀用於引用底層對象的名稱。然而由於每個對象都包含一個對其他對象的應用，因此引用計數不會歸零，對象也不會銷毀。（從而導致內存泄露）。為解決這一問題，解釋器會定期執行一個循環檢測器，搜索不可訪問對象的循環並刪除它們。
三、內存池機制
Python提供了對內存的垃圾收集機制，但是它將不用的內存放到內存池而不是返回給操作系統。
1，Pymalloc機制。為了加速Python的執行效率，Python引入了一個內存池機制，用於管理對小塊內存的申請和釋放。
2，Python中所有小於256個位元組的對象都使用pymalloc實現的分配器，而大的對象則使用系統的malloc。
3，對於Python對象，如整數，浮點數和List，都有其獨立的私有內存池，對象間不共享他們的內存池。也就是說如果你分配又釋放了大量的整數，用於緩存這些整數的內存就不能再分配給浮點數。
4. python的簡單問題
要把代碼發現來才知道，以下是常見的錯誤下面終於要講到當你用到更多的Python的功能（數據類型，函數，模塊，類等等）時可能碰到的問題了。由於篇幅有限，這里盡量精簡，尤其是對一些高級的概念。要想了解更多的細節，敬請閱讀Learning Python, 2nd Edition的逗小貼士地以及逗Gotchas地章節。 打開文件的調用不使用模塊搜索路徑當你在Python中調用open()來訪問一個外部的文件時，Python不會使用模塊搜索路徑來定位這個目標文件。它會使用你提供的絕對路徑，或者假定這個文件是在當前工作目錄中。模塊搜索路徑僅僅為模塊載入服務的。不同的類型對應的方法也不同列表的方法是不能用在字元串上的，反之亦然。通常情況下，方法的調用是和數據類型有關的，但是內部函數通常在很多類型上都可以使用。舉個例子來說，列表的reverse方法僅僅對列表有用，但是len函數對任何具有長度的對象都適用不能直接改變不可變數據類型記住你沒法直接的改變一個不可變的對象（例如，元組，字元串）： T = (1, 2, 3) T[2] = 4 # 錯誤 用切片，聯接等構建一個新的對象，並根據需求將原來變數的值賦給它。因為Python會自動回收沒有用的內存，因此這沒有看起來那麼浪費： T = T[:2] + (4,) # 沒問題了: T 變成了 (1, 2, 4) 使用簡單的for循環而不是while或者range 當你要從左到右遍歷一個有序的對象的所有元素時，用簡單的for循環（例如，for x in seq:）相比於基於while-或者range-的計數循環而言會更容易寫，通常運行起來也更快。除非你一定需要，盡量避免在一個for循環里使用range：讓Python來替你解決標號的問題。在下面的例子中三個循環結構都沒有問題，但是第一個通常來說更好；在Python里，簡單至上。 S = "lumberjack" for c in S: print c # 最簡單 for i in range(len(S)): print S[i] # 太多了 i = 0 # 太多了 while i len(S): print S[i]; i += 1 不要試圖從那些會改變對象的函數得到結果諸如像方法list.append()和list.sort()一類的直接改變操作會改變一個對象，但不會將它們改變的對象返回出來（它們會返回None）；正確的做法是直接調用它們而不要將結果賦值。經常會看見初學者會寫諸如此類的代碼： mylist = mylist.append(X) 目的是要得到append的結果，但是事實上這樣做會將None賦值給mylist，而不是改變後的列表。更加特別的一個例子是想通過用排序後的鍵值來遍歷一個字典里的各個元素，請看下面的例子： D = {...} for k in D.keys().sort(): print D[k] 差一點兒就成功了——keys方法會創建一個keys的列表，然後用sort方法來將這個列表排序——但是因為sort方法會返回None，這個循環會失敗，因為它實際上是要遍歷None（這可不是一個序列）。要改正這段代碼，將方法的調用分離出來，放在不同的語句中，如下： Ks = D.keys() Ks.sort() for k in Ks: print D[k] 只有在數字類型中才存在類型轉換在Python中，一個諸如123+3.145的表達式是可以工作的——它會自動將整數型轉換為浮點型，然後用浮點運算。但是下面的代碼就會出錯了： S = "42" I = 1 X = S + I # 類型錯誤 這同樣也是有意而為的，因為這是不明確的：究竟是將字元串轉換為數字（進行相加）呢，還是將數字轉換為字元串（進行聯接）呢看在Python中，我們認為逗明確比含糊好地（即，EIBTI（Explicit is better than implicit）），因此你得手動轉換類型： X = int(S) + I # 做加法: 43 X = S + str(I) # 字元串聯接: "421" 循環的數據結構會導致循環盡管這在實際情況中很少見，但是如果一個對象的集合包含了到它自己的引用，這被稱為循環對象（cyclic object）。如果在一個對象中發現一個循環，Python會輸出一個[…]，以避免在無限循環中卡住： >>> L = ['grail'] # 在 L中又引用L自身會 >>> L.append(L) # 在對象中創造一個循環 >>> L ['grail', [...]] 除了知道這三個點在對象中表示循環以外，這個例子也是很值得借鑒的。因為你可能無意間在你的代碼中出現這樣的循環的結構而導致你的代碼出錯。如果有必要的話，維護一個列表或者字典來表示已經訪問過的對象，然後通過檢查它來確認你是否碰到了循環。賦值語句不會創建對象的副本，僅僅創建引用這是Python的一個核心理念，有時候當行為不對時會帶來錯誤。在下面的例子中，一個列表對象被賦給了名為L的變數，然後L又在列表M中被引用。內部改變L的話，同時也會改變M所引用的對象，因為它們倆都指向同一個對象。 >>> L = [1, 2, 3] # 共用的列表對象 >>> M = ['X', L, 'Y'] # 嵌入一個到L的引用 >>> M ['X', [1, 2, 3], 'Y'] >>> L[1] = 0 # 也改變了M >>> M ['X', [1, 0, 3], 'Y'] 通常情況下只有在稍大一點的程序里這就顯得很重要了，而且這些共用的引用通常確實是你需要的。如果不是的話，你可以明確的給他們創建一個副本來避免共用的引用；對於列表來說，你可以通過使用一個空列表的切片來創建一個頂層的副本： >>> L = [1, 2, 3] >>> M = ['X', L[:], 'Y'] # 嵌入一個L的副本 >>> L[1] = 0 # 僅僅改變了L，但是不影響M >>> L [1, 0, 3] >>> M ['X', [1, 2, 3], 'Y'] 切片的范圍起始從默認的0到被切片的序列的最大長度。如果兩者都省略掉了，那麼切片會抽取該序列中的所有元素，並創造一個頂層的副本（一個新的，不被公用的對象）。對於字典來說，使用字典的dict.()方法。靜態識別本地域的變數名 Python默認將一個函數中賦值的變數名視作是本地域的，它們存在於該函數的作用域中並且僅僅在函數運行的時候才存在。從技術上講，Python是在編譯def代碼時，去靜態的識別本地變數，而不是在運行時碰到賦值的時候才識別到的。如果不理解這點的話，會引起人們的誤解。比如，看看下面的例子，當你在一個引用之後給一個變數賦值會怎麼樣： >>> X = 99 >>> def func(): ... print X # 這個時候還不存在 ... X = 88 # 在整個def中將X視作本地變數 ... >>> func( ) # 出錯了！ 你會得到一個逗未定義變數名地的錯誤，但是其原因是很微妙的。當編譯這則代碼時，Python碰到給X賦值的語句時認為在這個函數中的任何地方X會被視作一個本地變數名。但是之後當真正運行這個函數時，執行print語句的時候，賦值語句還沒有發生，這樣Python便會報告一個逗未定義變數名地的錯誤。事實上，之前的這個例子想要做的事情是很模糊的：你是想要先輸出那個全局的X，然後創建一個本地的X呢，還是說這是個程序的錯誤看如果你真的是想要輸出這個全局的X，你需要將它在一個全局語句中聲明它，或者通過包絡模塊的名字來引用它。默認參數和可變對象在執行def語句時，默認參數的值只被解析並保存一次，而不是每次在調用函數的時候。這通常是你想要的那樣，但是因為默認值需要在每次調用時都保持同樣對象，你在試圖改變可變的默認值（mutable defaults）的時候可要小心了。例如，下面的函數中使用一個空的列表作為默認值，然後在之後每一次函數調用的時候改變它的值： >>> def saver(x=[]): # 保存一個列表對象 ... x.append(1) # 並每次調用的時候 ... print x # 改變它的值 ... >>> saver([2]) # 未使用默認值 [2, 1] >>> saver() # 使用默認值 [1] >>> saver() # 每次調用都會增加！ [1, 1] >>> saver() [1, 1, 1] 有的人將這個視作Python的一個特點——因為可變的默認參數在每次函數調用時保持了它們的狀態，它們能提供像C語言中靜態本地函數變數的類似的一些功能。但是，當你第一次碰到它時會覺得這很奇怪，並且在Python中有更加簡單的辦法來在不同的調用之間保存狀態（比如說類）。要擺脫這樣的行為，在函數開始的地方用切片或者方法來創建默認參數的副本，或者將默認值的表達式移到函數裡面；只要每次函數調用時這些值在函數里，就會每次都得到一個新的對象： >>> def saver(x=None): ... if x is None: x = [] # 沒有傳入參數看 ... x.append(1) # 改變新的列表 ... print x ... >>> saver([2]) # 沒有使用默認值 [2, 1] >>> saver() # 這次不會變了 [1] >>> saver() [1] 其他常見的編程陷阱下面列舉了其他的一些在這里沒法詳述的陷阱：在頂層文件中語句的順序是有講究的：因為運行或者載入一個文件會從上到下運行它的語句，所以請確保將你未嵌套的函數調用或者類的調用放在函數或者類的定義之後。 reload不影響用from載入的名字：reload最好和import語句一起使用。如果你使用from語句，記得在reload之後重新運行一遍from，否則你仍然使用之前老的名字。在多重繼承中混合的順序是有講究的：這是因為對superclass的搜索是從左到右的，在類定義的頭部，在多重superclass中如果出現重復的名字，則以最左邊的類名為准。在try語句中空的except子句可能會比你預想的捕捉到更多的錯誤。在try語句中空的except子句表示捕捉所有的錯誤，即便是真正的程序錯誤，和sys.exit()調用，也會被捕捉到。
5. Python哪些知識重要
一、Python是如何進行內存管理的？
先說明一點，Python每創建一個對象，這個對象都是一個三元組（標識，類型，值）。當我們調用一個對象時一般是按引用傳遞，
有必要時才按值傳遞。（按引用不新建對象，按值則會新建對象）
1.引用計數機制
創建對象後，每分配一個名稱或將對象放入一個容器時，該對象的引用計數都會增加；
每del一個名稱或者引用超出作用域或者被重新賦值時，該對象的引用計數就會減少。
當引用計數歸零時，它將被垃圾收集機制處理掉。
2.內存池機制
Python提供了對內存的垃圾收集機制，但是它將不用的內存放到內存池而不是返回給操作系統。
Python中所有小於256個位元組的對象都使用pymalloc實現的分配器，而大的對象則使用系統的 malloc。
其中不同類型的對象，如整數，浮點數和List，都有其獨立的私有內存池，對象間不共享內存池。
二、try…except…except…[else…][finally…]
python先嘗試執行try下語句：
若異常，則分別與數個except異常匹配，並執行相匹配的except語句，若都不匹配則異常會傳遞到最高層try中，最後執行fanally語句；
若無異常，則執行else語句，最後執行fanally語句。
6. 為什麼說python採用的是基於值的內存管理模式
先從較淺的層面來說，Python的內存管理機制可以從三個方面來講
（1）垃圾回收
（2）引用計數
（3）內存池機制
一、垃圾回收：
python不像C++，Java等語言一樣，他們可以不用事先聲明變數類型而直接對變數進行賦值。對Python語言來講，對象的類型和內存都是
在運行時確定的。這也是為什麼我們稱Python語言為動態類型的原因（這里我們把動態類型可以簡單的歸結為對變數內存地址的分配是在運行時自動判斷變數
類型並對變數進行賦值）。
二、引用計數：
Python採用了類似Windows內核對象一樣的方式來對內存進行管理。每一個對象，都維護這一個對指向該對對象的引用的計數。如圖所示（圖片來自Python核心編程）
x = 3.14
y = x
我們首先創建了一個對象3.14， 然後將這個浮點數對象的引用賦值給x，因為x是第一個引用，因此，這個浮點數對象的引用計數為1. 語句y =
x創建了一個指向同一個對象的引用別名y，我們發現，並沒有為Y創建一個新的對象，而是將Y也指向了x指向的浮點數對象，使其引用計數為2.
我們可以很容易就證明上述的觀點：
變數a 和 變數b的id一致(我們可以將id值想像為C中變數的指針).
我們援引另一個網址的圖片來說明問題：對於C語言來講，我們創建一個變數A時就會為為該變數申請一個內存空間，並將變數值
放入該空間中,當將該變數賦給另一變數B時會為B申請一個新的內存空間，並將變數值放入到B的內存空間中，這也是為什麼A和B的指針不一致的原因。如圖：
而Python的情況卻不一樣，實際上，Python的處理方式和Javascript有點類似，如圖所示，變數更像是附在對象上的標簽(和引用的
定義類似)。當變數被綁定在一個對象上的時候，該變數的引用計數就是1，(還有另外一些情況也會導致變數引用計數的增加),系統會自動維護這些標簽，並定
時掃描，當某標簽的引用計數變為0的時候，該對就會被回收。
三、內存池機制
Python的內存機制以金字塔行，-1，-2層主要有操作系統進行操作，
第0層是C中的malloc，free等內存分配和釋放函數進行操作；
第1層和第2層是內存池，有Python的介面函數PyMem_Malloc函數實現，當對象小於256K時有該層直接分配內存；
第3層是最上層，也就是我們對Python對象的直接操作；
在 C 中如果頻繁的調用 malloc 與 free 時,是會產生性能問題的.再加上頻繁的分配與釋放小塊的內存會產生內存碎片. Python 在這里主要乾的工作有:
如果請求分配的內存在1~256位元組之間就使用自己的內存管理系統,否則直接使用 malloc.
這里還是會調用 malloc 分配內存,但每次會分配一塊大小為256k的大塊內存.
經由內存池登記的內存到最後還是會回收到內存池,並不會調用 C 的 free
釋放掉.以便下次使用.對於簡單的Python對象，例如數值、字元串，元組（tuple不允許被更改)採用的是復制的方式(深拷貝?)，也就是說當將另
一個變數B賦值給變數A時，雖然A和B的內存空間仍然相同，但當A的值發生變化時，會重新給A分配空間，A和B的地址變得不再相同；
而對於像字典(dict)，列表(List)等，改變一個就會引起另一個的改變，也稱之為淺拷貝：
附錄：
引用計數增加
1.對象被創建：x=4
2.另外的別人被創建：y=x
3.被作為參數傳遞給函數：foo(x)
4.作為容器對象的一個元素：a=[1,x,』33』]
引用計數減少
1.一個本地引用離開了它的作用域。比如上面的foo(x)函數結束時，x指向的對象引用減1。
2.對象的別名被顯式的銷毀：del x ；或者del y
3.對象的一個別名被賦值給其他對象：x=789
4.對象從一個窗口對象中移除：myList.remove(x)
5.窗口對象本身被銷毀：del myList，或者窗口對象本身離開了作用域。
垃圾回收
1、當內存中有不再使用的部分時，垃圾收集器就會把他們清理掉。它會去檢查那些引用計數為0的對象，然後清除其在內存的空間。當然除了引用計數為0的會被清除，還有一種情況也會被垃圾收集器清掉：當兩個對象相互引用時，他們本身其他的引用已經為0了。
2、垃圾回收機制還有一個循環垃圾回收器, 確保釋放循環引用對象(a引用b, b引用a, 導致其引用計數永遠不為0)。
7. Python引入了一個機制：引用計數。
python內部使用引用計數，來保持追蹤內存中的對象，
Python內部記錄了對象有多少個引用
，即引用計數，當對象被創建時就創建了一個引用計數，當對象不再需要時，這個對象的引用計數為0時，它被垃圾回收。
總結一下對象會在一下情況下引用計數加1：
1.對象被創建：x=4
2.另外的別人被創建：y=x
3.被作為參數傳遞給函數：foo(x)
4.作為容器對象的一個元素：a=[1,x,'33']
引用計數減少情況
1.一個本地引用離開了它的作用域。比如上面的foo(x)函數結束時，x指向的對象引用減1。
2.對象的別名被顯式的銷毀：del x ；或者del y
3.對象的一個別名被賦值給其他對象：x=789
4.對象從一個窗口對象中移除：myList.remove(x)
5.窗口對象本身被銷毀：del myList，或者窗口對象本身離開了作用域。垃圾回收
1、當內存中有不再使用的部分時，垃圾收集器就會把他們清理掉。
它會去檢查那些引用計數為0的對象
，然後清除其在內存的空間。當然除了引用計數為0的會被清除，還有一種情況也會被垃圾收集器清掉：當兩個對象相互引用時，他們本身其他的引用已經為0了。
2、垃圾回收機制還有一個
循環垃圾回收器
, 確保釋放循環引用對象(a引用b, b引用a, 導致其引用計數永遠不為0)。
在Python中，許多時候申請的內存都是小塊的內存，這些小塊內存在申請後，很快又會被釋放，由於這些內存的申請並不是為了創建對象，所以並沒有對象一級的內存池機制。
這就意味著Python在運行期間會大量地執行malloc和free的操作，頻繁地在用戶態和核心態之間進行切換，這將嚴重影響Python的執行效率。為了加速Python的執行效率，Python引入了一個內存池機制，用於管理對小塊內存的申請和釋放。
內存池機制
Python提供了對內存的垃圾收集機制，但是它將不用的內存放到內存池而不是返回給操作系統。
Python中所有小於256個位元組的對象都使用pymalloc實現的分配器，而大的對象則使用系統的
malloc。另外Python對象，如整數，浮點數和List，都有其獨立的私有內存池，對象間不共享他們的內存池。也就是說如果你分配又釋放了大量的整數，用於緩存這些整數的內存就不能再分配給浮點數。
在Python中，許多時候申請的內存都是小塊的內存，這些小塊內存在申請後，很快又會被釋放，由於這些內存的申請並不是為了創建對象，所以並沒有對象一級的內存池機制。這就意味著Python在運行期間會大量地執行malloc和free的操作，頻繁地在用戶態和核心態之間進行切換，這將嚴重影響
Python的執行效率。這也就是之前提到的