python哈希表添加元素

『壹』 python如何哈希字元串

Python中字元串是可哈希的，即可以作為字典的鍵或者HashTable的鍵使用。

您可以這樣子使用Python內置函數hash（散列函數）：

總之，Python裡面有很多內置的hash功能性數據結構和函數。

『貳』 python字典添加元素時怎麼判斷加到了字典的哪個位置

字典對用戶來說是無序的，python會基於快速檢索的需求，自己對他們進行排序。
如果你非常想明白這個問題，可以去學一下數據結構裡面的哈希。

『叄』 如何用Python構造hash表解決DNA k-mer問題

思路：
1、首先採用命A=0,C=1,G=2,T=3. 就相當於4進制數字，然後採用karp-Rabin演算法轉換成唯一十進制數字。由於用此演算法的哈希函數為：hash(value)=value*(4^(k-q-1));
value是該字元對應的值，k是kmer長度,q是此字元在字元串的位置范圍在[0-(q-1)]。然後把一個kmer裡面所有字元的hash值求和就行了。
2、那麼很容易看出來，對於連續的下害常憤端蒞得縫全俯戶一個Kmer，就有推理公式了 hashNew=addValue+(hashOld-deleteValue*(4^(k-1)))*4; hashNew就是往右平移一個字元的kmer hash值，hashOld就是平移之前的值，addValue就是平移後右邊多的一個字元，deleteValue就是平移後左邊少的一個字元。這樣整個hash表建立的時間復雜度約為O（m+k）,m是整個文本長度。
3、由於kmer長度如果過長，其hash值過大，會造成內存不夠溢出的現象，所以kmer內部定死為10 。那麼問題就來了，如何應對不同的kmer值。分三種情況。
第一種：q>10
這種可以將kmer以10為單位，將hash表中對應值取出，然後對結果進行分析，這邊分析方法為建立兩個數組一個二維數組unionName儲存位置關系，一個一維數組unionScore,計數用。 思路就是首先第一輪初始化unionName[Name][Pos]全部賦值Pos 並初始化unionScore，然後再第二輪匹配如果unionName[Name][Pos-cycle]=Pos-1則將其賦值為當前Pos，cycle為當前循環次數。並將當前循環數存入unionScore[NAME]中。最後當unionScore[NAME]值也就是循環數為k-1，即我們需要的交集了。
第二種：q=10
直接求出hash值，取出相應的值即可。
第三種：q<10
可以用前綴種子+後綴種子交集產生。
前綴種子：在字元串後面補字元直到長度等於K，這個很容易看出來 最小是全補A，最大是全補T，然後將最小值到最大值之間的hash值即為所求。
後綴種子：後綴種子和前綴種子不同就是在字元串左邊補齊字元。所以此時需要進行變換。只要對前置種子產生的值變化下就行了。(preValue-minValue)*(4^(K-q))+hash(p) 。其中preValue就是對應的前置種子的hash值，minValue就是前置種子中最小值也就是全補A的情況，hash（p）就是字元串長度為p時候的hash值。
交集就是先求後綴種子所有的值，再加上 前綴種子中起始位置在[0-(k-1)]中的值。

『肆』 什麼是哈希表特點是什麼

簡單說就是按照哈希函數關系建立的表
具體內容請參考數據結構相關知識~
下面引用一些別的地方
1 基本原理

我們使用一個下標范圍比較大的數組來存儲元素。可以設計一個函數（哈希函數），使得每個元素的關鍵字都與一個函數值（即數組下標）相對應，於是用這個數組單元來存儲這個元素；也可以簡單的理解為，按照關鍵字為每一個元素"分類"，然後將這個元素存儲在相應"類"所對應的地方。

但是，不能夠保證每個元素的關鍵字與函數值是一一對應的，因此極有可能出現對於不同的元素，卻計算出了相同的函數值，這樣就產生了"沖突"，換句話說，就是把不同的元素分在了相同的"類"之中。後面我們將看到一種解決"沖突"的簡便做法。

總的來說，"直接定址"與"解決沖突"是哈希表的兩大特點。

2 函數構造

構造函數的常用方法（下面為了敘述簡潔，設 h(k) 表示關鍵字為 k 的元素所對應的函數值）：

a) 除余法：

選擇一個適當的正整數 p ，令 h(k ) = k mod p
這里， p 如果選取的是比較大的素數，效果比較好。而且此法非常容易實現，因此是最常用的方法。

b) 數字選擇法：

如果關鍵字的位數比較多，超過長整型範圍而無法直接運算，可以選擇其中數字分布比較均勻的若干位，所組成的新的值作為關鍵字或者直接作為函數值。

3 沖突處理

線性重新散列技術易於實現且可以較好的達到目的。令數組元素個數為 S ，則當 h(k) 已經存儲了元素的時候，依次探查 (h(k)+i) mod S , i=1,2,3…… ，直到找到空的存儲單元為止（或者從頭到尾掃描一圈仍未發現空單元，這就是哈希表已經滿了，發生了錯誤。當然這是可以通過擴大數組范圍避免的）。

4 支持運算

哈希表支持的運算主要有：初始化(makenull)、哈希函數值的運算(h(x))、插入元素(insert)、查找元素(member)。
設插入的元素的關鍵字為 x ，A 為存儲的數組。
初始化比較容易，例如
const empty=maxlongint; // 用非常大的整數代表這個位置沒有存儲元素
p=9997; // 表的大小
procere makenull;
var i:integer;
begin
for i:=0 to p-1 do
A[i]:=empty;
End;

哈希函數值的運算根據函數的不同而變化，例如除余法的一個例子：
function h(x:longint):Integer;
begin
h:= x mod p;
end;

我們注意到，插入和查找首先都需要對這個元素定位，即如果這個元素若存在，它應該存儲在什麼位置，因此加入一個定位的函數 locate
function locate(x:longint):integer;
var orig,i:integer;
begin
orig:=h(x);
i:=0;
while (i<S)and(A[(orig+i)mod S]<>x)and(A[(orig+i)mod S]<>empty) do
inc(i);
//當這個循環停下來時，要麼找到一個空的存儲單元，要麼找到這個元
//素存儲的單元，要麼表已經滿了
locate:=(orig+i) mod S;
end;
插入元素
procere insert(x:longint);
var posi:integer;
begin
posi:=locate(x); //定位函數的返回值
if A[posi]=empty then A[posi]:=x
else error; //error 即為發生了錯誤，當然這是可以避免的
end;

查找元素是否已經在表中
procere member(x:longint):boolean;
var posi:integer;
begin
posi:=locate(x);
if A[posi]=x then member:=true
else member:=false;
end;

這些就是建立在哈希表上的常用基本運算。

『伍』 python hashcode方法嗎

一、在Object類中的定義為: public native int hashCode(); 是一個本地方法，返回的對象的地址值。 但是，同樣的思路，在String等封裝類中對此方法進行了重寫。方法調用得到一個計算公式得到的 int值。 二、在重寫任何類得hashcode方法時必須遵循以下幾點： 1、在java應用的同一次執行過程中，同一對象被多次調用，則他們的hashcode值必然相同。而對於同一個應用的兩次不同的調用，它們的Hashcode值可以相同，也有可能不同。 2、對於兩個對象來說，如果他們的equals方法比較返回true，那麼這兩個對象的hashcode必然相同。這也解釋了為什麼String類中，如果兩個對象的equals方法相同，則他們的hashcode值一定相同。 3、對於兩個對象來說，如果使用equals方法返回為false，則他們的hashcode的值有可能相等也可能不等，（如果不同會提高性能，因為在集合中類判斷兩個對象是否相等，如果其hashcode不等就直接不用判斷equals方法了） 4、對於Object對象來說，不同的Object對象的hashcode是不同的，它們返回的是對象的地址，equals返回的也是對象的地址。所以在自己定義的類中如果要添加到集合對象中，最好是要重寫hashcode和equals方法，不然會自動繼承自Object類中的兩個方法根據對象地址來判斷。在重寫自己定義的類時，通常是在類中的根據某個值如name.hashcode();來進行判斷。 三、以HashSet 為例： 當我們使用HashSet時，hashCode()方法就會被得到調用，判斷已經存儲在集合中的對象的hashCode值是否與所增加。 對象的hashCode值一致，如果「不一致」則直接加進去（不用比較equals()提高效率），如果一致，則進行equals方法的比較，如果返回true，表明集合裡面已經有這個對象，不能添加進去了。如果是false表是集合裡面沒有這個對象，則可以加進去。所以在重寫hashcode()或者equals() 方法的任何一個方法時，必須重寫另外一個。 示例代碼： /** * People 手工重寫hashcode方法和equals方法 根據name來判斷 兩個對象是否相等。 */ class People { private String name; public People(String name) { this.name = name; } @Override public boolean equals(Object obj) { //如果是自己 if(this==obj){ return true ; } //如果是空 if(obj==null ){ return false; } //比較兩個People的名字是否相同 if(obj!=null && obj instanceof People){ if(((People)obj).name.equals(this.name)) return true ; } return false; } @Override public int hashCode() { // String的hashcode本來就是用來比較兩個字元是否相等 return name.hashCode(); } }

『陸』 python的hash函數問題

這里的大小是集合的（即容納的元素），不是裡面元素的大小。
舉個不恰當的例子｛牛肉、豆腐、白菜、刀子｝ -> {可以吃的東西、不能吃的東西}
前者有4種，後者有2種，但是前者的字並不比後者的字多。

『柒』 python中 __hash__ 怎麼用 可以舉一個簡單的例子嗎

主要是語言內部使用的，程序員（使用者）通常可以不管

『捌』 數據結構 哈希表建立

有些圖打不上去。如果想要完整的資料告訴我郵箱，我發給你 。

哈希表及其應用
一、定義
二、基本原理
哈希表的基本原理是：使用一個下標范圍比較大的數組A來存儲元素，設計一個函數h，對於要存儲的線性表的每個元素node，取一個關鍵字key，算出一個函數值h(key)，把h(key)作為數組下標，用A[h(key)]這個數組單元來存儲node。也可以簡單的理解為，按照關鍵字為每一個元素「分類」，然後將這個元素存儲在相應「類」所對應的地方（這一過程稱為「直接定址」）。
但是，不能夠保證每個元素的關鍵字與函數值是一一對應的，因此極有可能出現對於不同的元素，卻計算出了相同的函數值，這樣就產生了「沖突」，換句話說，就是把不同的元素分在了相同的「類」之中。例如，假設一個結點的關鍵碼值為key，把它存入哈希表的過程是：根據確定的函數h計算出h(key)的值，如果以該值為地址的存儲空間還沒有被佔用，那麼就把結點存入該單元；如果此值所指單元里已存了別的結點（即發生了沖突），那麼就再用另一個函數I進行映象算出I(h(key)),再看用這個值作為地址的單元是否已被佔用了，若已被佔用，則再用I映象，……，直到找到一個空位置將結點存入為止。當然這只是解決「沖突」的一種簡單方法，如何避免、減少和處理「沖突」是使用哈希表的一個難題。
在哈希表中查找的過程與建立哈希表的過程相似，首先計算h(key)的值，以該值為地址到基本區域中去查找。如果該地址對應的空間未被佔用，則說明查找失敗，否則用該結點的關鍵碼值與要找的key比較，如果相等則檢索成功，否則要繼續用函數I計算I(h(key))的值，……。如此反復到某步或者求出的某地址空間未被佔用（查找失敗）或者比較相等（查找成功）為止。
三、基本概念和簡單實現
1、兩個集合：U是所有可能出現的關鍵字集合；K是實際存儲的關鍵字集合。
2、函數h將U映射到表T[0..m-1]的下標上，可以表示成 h：U→{0，1，2，...，m-1}，通常稱h為「哈希函數(Hash Function)」，其作用是壓縮待處理的下標范圍，使待處理的|U|個值減少到m個值，從而降低空間開銷（註：|U|表示U中關鍵字的個數，下同）。
3、將結點按其關鍵字的散列地址存儲到哈希表（散列表）中的過程稱為「散列(Hashing)」。方法稱為「散列法」。
4、h(Ki)(Ki∈U)是關鍵字為Ki的結點的「存儲地址」，亦稱散列值、散列地址、哈希地址。
5、用散列法存儲的線性表稱為「哈希表（Hash Table）」，又稱散列表。圖中T即為哈希表。在散列表裡可以對結點進行快速檢索（查找）。
6、對於關鍵字為key的結點，按照哈希函數h計算出地址h(key)，若發現此地址已被別的結點佔用，也就是說有兩個不同的關鍵碼值key1和key2對應到同一個地址，即h(key1)=h(key2)，這個現象叫做「沖突（碰撞）」。碰撞的兩個（或多個）關鍵碼稱為「同義詞」（相對於函數h而言）。如圖1中的關鍵字k2和k5，h(k2)=h(k5)，即發生了「沖突」，所以k2和k5稱為「同義詞」。假如先存了k2，則對於k5，我們可以存儲在h(k2)+1中，當然h(k2)+1要為空，否則可以逐個往後找一個空位存放。這是另外一種簡單的解決沖突的方法。
發生了碰撞就要想辦法解決，必須想辦法找到另外一個新地址，這當然要降低處理效率，因此我們希望盡量減少碰撞的發生。這就需要分析關鍵碼集合的特性，找適當的哈希函數h使得計算出的地址盡可能「均勻分布」在地址空間中。同時，為了提高關鍵碼到地址轉換的速度，也希望哈希函數「盡量簡單」。然而對於各種取值的關鍵碼而言，一個好的哈希函數通常只能減少碰撞發生的次數，無法保證絕對不產生碰撞。因此散列除去要選擇適當的哈希函數以外，還要研究發生碰撞時如何解決，即用什麼方法存儲同義詞。
7、負載因子
我們把h(key)的值域所對應到的地址空間稱為「基本區域」，發生碰撞時，同義詞可以存放在基本區域還沒有被佔用的單元里，也可以放到基本區域以外另開辟的區域中（稱為「溢出區」）。下面引入散列的一個重要參數「負載因子或裝填因子(Load Factor)」，它定義為：
а=
負載因子的大小對於碰撞的發生頻率影響很大。直觀上容易想像，а越大，散列表裝得越滿，則再要載入新的結點時碰上已有結點的可能性越大，沖突的機會也越大。特別當а＞1時碰撞是不可避免的。一般總是取а＜1，即分配給散列表的基本區域大於所有結點所需要的空間。當然分配的基本區域太大了也是浪費。例如，某校學生幹部的登記表，每個學生幹部是一個結點，用學號做關鍵碼，每個學號用7位數字表示，如果分配給這個散列表的基本區域為107個存儲單元，那麼散列函數就可以是個恆等變換，學號為7801050的學生結點就存入相對地址為7801050的單元，這樣一次碰撞也不會發生，但學校僅幾百個學生幹部，實際僅需要幾百個單元的空間，如果佔用了107個存儲單元，顯然太浪費了，所以這是不可取的。負載因子的大小要取得適當，使得既不過多地增加碰撞，有較快的檢索速度，也不浪費存儲空間。
下面結合引例說明一下上面的思想和方法。
【例1】用散列存儲線性表：A=（18，75，60，43，54，90，46）。
分析：
假定選取的散列函數為：h(K)=K mod m，K為元素的關鍵字，m為散列表的長度，用余數作為存儲該元素的散列地址。這里假定K和m均為正整數，並且m要大於等於線性表的長度n。此例n=7，故假定取m=13，則得到的每個元素的散列地址為：
h(18)=18 mod 13=5 h(75)=75 mod 13 =10 h(60)=60 mod 13=8
h(43)=43 mod 13=4 h(54)=54 mod 13=2 h(90)=90 mod 13=12
h(46)=46 mod 13=7
根據散列地址按順序把元素存儲到散列表H（0：m-1）中，存儲映象為：
0 1 2 3 4 5 6 7 8 9 10 11 12

54 43 18 46 60 75 90
當然這是一個比較理想的情況。假如再往表中插入第8個元素30，h(30)=30 mod 13=4，我們會發現H[4]已經存了43，此時就發生了沖突。我們可以從H[4]往後按順序找一個空位置存放30，即可以把它插入到H[6]中。

四、哈希函數的構造方法
選擇適當的哈希函數是實現散列的重中之重，構造哈希函數有兩個標准：簡單和均勻。簡單是指哈希函數的計算要簡單快速；均勻是指對於關鍵字集合中的任一關鍵字，哈希函數能以等概率將其映射到表空間的任何一個位置上。也就是說，哈希函數能將子集K隨機均勻地分布在表的地址集{0，1，...，m-1}上，以使沖突最小化。
為簡單起見，假定關鍵碼是定義在自然數集合上，常見的哈希函數構造方法有：
1、直接定址法
以關鍵字Key本身或關鍵字加上某個數值常量C作為散列地址的方法。散列函數為：h(Key)= Key+C，若C為0，則散列地址就是關鍵字本身。

2、除余法
選擇一個適當的正整數m，用m去除關鍵碼，取其餘數作為地址，即：h(Key)= Key mod m，這個方法應用的最多，其關鍵是m的選取,一般選m為小於某個區域長度n的最大素數（如例1中取m=13），為什麼呢？就是為了盡力避免沖突。假設取m=1000 ，則哈希函數分類的標准實際上就變成了按照關鍵字末三位數分類，這樣最多1000類，沖突會很多。一般地說，如果 m 的約數越多，那麼沖突的幾率就越大。
簡單的證明：假設m是一個有較多約數的數，同時在數據中存在q滿足gcd(m,q)=d >1 ，即有m=a*d,q=b*d,則有以下等式：q mod m= q – m* [q div m] =q – m*[b div a] 。
其中，[b div a]的取值范圍是不會超過[0，b]的正整數。也就是說，[b div a]的值只有b+1種可能，而m是一個預先確定的數。因此上式的值就只有b+1種可能了。這樣，雖然mod 運算之後的余數仍然在[0，m-1]內，但是它的取值僅限於等式可能取到的那些值。也就是說余數的分布變得不均勻了。容易看出，m的約數越多，發生這種余數分布不均勻的情況就越頻繁，沖突的幾率越高。而素數的約數是最少的，因此我們選用大素數。記住「素數是我們的得力助手」。

3、數字分析法
常有這樣的情況：關鍵碼的位數比存儲區域的地址的位數多，在這種情況下可以對關鍵碼的各位進行分析，丟掉分布不均勻的位留下分布均勻的位作為地址。
本方法適用於所有關鍵字已知，並對關鍵字中每一位的取值分布情況作出了分析。
【例2】對下列關鍵碼集合（表中左邊一列）進行關鍵碼到地址的轉換，要求用三位地址。
Key H(Key)
000319426 326
000718309 709
000629443 643
000758615 715
000919697 997
000310329 329

分析：
關鍵碼是9位的，地址是3位的，需要經過數字分析丟掉6位。丟掉哪6位呢？顯然前3位是沒有任何區分度，第5位1太多、第6位基本都是8和9、第7位都是3、4、5，這幾位的區分度都不好，而相對來說，第4、8、9位分布比較均勻，所以留下這3位作為地址（表中右邊一列）。

4、平方取中法
將關鍵碼的值平方，然後取中間的幾位作為散列地址。具體取多少位視實際要求而定，取哪幾位常常結合數字分析法。
【例3】將一組關鍵字(0100，0110，1010，1001，0111)平方後得(0010000，0012100，1020100，1002001，0012321)，若取表長為1000，則可取中間的三位數作為散列地址集：
(100，121，201，020，123)。

5、折疊法
如果關鍵碼的位數比地址碼的位數多，而且各位分布較均勻，不適於用數字分析法丟掉某些數位，那麼可以考慮用折疊法。折疊法是將關鍵碼從某些地方斷開，分關鍵碼為幾個部分，其中有一部分的長度等於地址碼的長度，然後將其餘部分加到它的上面，如果最高位有進位，則把進位丟掉。
一般是先將關鍵字分割成位數相同的幾段（最後一段的位數可少一些），段的位數取決於散列地址的位數，由實際需要而定，然後將它們的對應位疊加和（捨去最高位進位）作為散列地址。
【例4】如關鍵碼Key=58422241，要求轉換為3位的地址碼。
分析：分如下3段：5 8 4 | 2 2 2 | 4 1，則相加：
5 8 4
2 2 2
4 1
8 4 7
h(Key)=847

6、基數轉換法
將關鍵碼值看成在另一個基數制上的表示，然後把它轉換成原來基數制的數，再用數字分析法取其中的幾位作為地址。一般取大於原來基數的數作轉換的基數，並且兩個基數要是互質的。如：key=(236075)10是以10為基數的十進制數，現在將它看成是以13為基數的十三進制數(236075)13,然後將它轉換成十進制數。
（236075）13=2*135+3*134+6*133+7*13+5
=(841547)10
再進行數字分析，比如選擇第2,3,4,5位，於是h(236075)=4154

五、哈希表支持的運算
哈希表支持的運算主要有：初始化(makenull)、哈希函數值的運算(h(x))、插入元素(insert)、查找元素(member)。設插入元素的關鍵字為 x ，A 為哈希表，則各種運算過程如下：

1、初始化比較容易，例如：
const empty=maxlongint; {用非常大的整數代表這個位置沒有存儲元素}
p=9997; {根據需要設定的表的大小}
procere makenull;
var i:integer;
begin
for i:=0 to p-1 do A[i]:=empty;
End;

2、哈希函數值的運算，根據函數的不同而變化，例如除余法的一個例子：
function h(x:longint):Integer;
begin
h:= x mod p;
end;

3、我們注意到，插入和查找首先都需要對這個元素定位，因此加入一個定位的函數 locate：
function locate(x:longint):integer;
var orig,i:integer;
begin
orig:=h(x);
i:=0;
while (i<P)and(A[(orig+i)mod P]<>x)and(A[(orig+i)mod P]<>empty) do inc(i);
{當這個循環停下來時，要麼找到一個空的存儲單元，
要麼找到這個元素存儲的單元，要麼表已經滿了}
locate:=(orig+i) mod P;
end;

4、插入元素：
procere insert(x:longint);
var posi:integer;
begin
posi:=locate(x); {定位函數的返回值}
if A[posi]=empty then A[posi]:=x
else error; {error 即為發生了錯誤，當然這是可以避免的}
end;

5、查找元素是否已經在表中：
procere member(x:longint):boolean;
var pos:integer;
begin
pos:=locate(x);
if A[pos]=x then member:=true
else member:=false;
end;

『玖』 python里是否有相當於java或C#的哈希表的東西

不能使用對象本身作為鍵值，但你可以考慮使用對象的id作為鍵值。因為id值是唯一的！

a={'foo':'bar'}
b={id(a):'bar'}

如有幫助，請採納，謝謝！

『拾』 python 列表內有字典怎麼使用

Python字典是另一種可變容器模型，且可存儲任意類型對象，如字元串、數字、元組等其他容器模型。
一、創建字典
字典由鍵和對應值成對組成。字典也被稱作關聯數組或哈希表。基本語法如下：

復制代碼代碼如下:
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}

也可如此創建字典：

復制代碼代碼如下:
dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };

注意：
每個鍵與值用冒號隔開（:），每對用逗號，每對用逗號分割，整體放在花括弧中（{}）。
鍵必須獨一無二，但值則不必。
值可以取任何數據類型，但必須是不可變的，如字元串，數或元組。
二、訪問字典里的值
把相應的鍵放入熟悉的方括弧，如下實例:

復制代碼代碼如下:
#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

print "dict['Name']: ", dict['Name'];
print "dict['Age']: ", dict['Age'];
#以上實例輸出結果：
#dict['Name']: Zara
#dict['Age']: 7

如果用字典里沒有的鍵訪問數據，會輸出錯誤如下：

復制代碼代碼如下:
#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

print "dict['Alice']: ", dict['Alice'];

#以上實例輸出結果：
#dict['Zara']:
#Traceback (most recent call last):
# File "test.py", line 4, in <mole>
# print "dict['Alice']: ", dict['Alice'];
#KeyError: 'Alice'[/code]
三、修改字典
向字典添加新內容的方法是增加新的鍵/值對，修改或刪除已有鍵/值對如下實例:

復制代碼代碼如下:
#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

dict['Age'] = 8; # update existing entry
dict['School'] = "DPS School"; # Add new entry

print "dict['Age']: ", dict['Age'];
print "dict['School']: ", dict['School'];
#以上實例輸出結果：
#dict['Age']: 8
#dict['School']: DPS School

四、刪除字典元素
能刪單一的元素也能清空字典，清空只需一項操作。
顯示刪除一個字典用del命令，如下實例：

復制代碼代碼如下:
#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

del dict['Name']; # 刪除鍵是'Name'的條目
dict.clear(); # 清空詞典所有條目
del dict ; # 刪除詞典

print "dict['Age']: ", dict['Age'];
print "dict['School']: ", dict['School'];
#但這會引發一個異常，因為用del後字典不再存在：
dict['Age']:
#Traceback (most recent call last):
# File "test.py", line 8, in <mole>
# print "dict['Age']: ", dict['Age'];
#TypeError: 'type' object is unsubscriptable

五、字典鍵的特性
字典值可以沒有限制地取任何python對象，既可以是標準的對象，也可以是用戶定義的，但鍵不行。
兩個重要的點需要記住：
1）不允許同一個鍵出現兩次。創建時如果同一個鍵被賦值兩次，後一個值會被記住，如下實例：

復制代碼代碼如下:
#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'};

print "dict['Name']: ", dict['Name'];
#以上實例輸出結果：
#dict['Name']: Manni

2）鍵必須不可變，所以可以用數，字元串或元組充當，所以用列表就不行，如下實例：

復制代碼代碼如下:
#!/usr/bin/python

dict = {['Name']: 'Zara', 'Age': 7};

print "dict['Name']: ", dict['Name'];
#以上實例輸出結果：
#Traceback (most recent call last):
# File "test.py", line 3, in <mole>
# dict = {['Name']: 'Zara', 'Age': 7};
#TypeError: list objects are unhashable

六、字典內置函數&方法
Python字典包含了以下內置函數：
1、cmp(dict1, dict2)：比較兩個字典元素。
2、len(dict)：計算字典元素個數，即鍵的總數。
3、str(dict)：輸出字典可列印的字元串表示。
4、type(variable)：返回輸入的變數類型，如果變數是字典就返回字典類型。
Python字典包含了以下內置方法：
1、radiansdict.clear()：刪除字典內所有元素
2、radiansdict.()：返回一個字典的淺復制
3、radiansdict.fromkeys()：創建一個新字典，以序列seq中元素做字典的鍵，val為字典所有鍵對應的初始值
4、radiansdict.get(key, default=None)：返回指定鍵的值，如果值不在字典中返回default值
5、radiansdict.has_key(key)：如果鍵在字典dict里返回true，否則返回false
6、radiansdict.items()：以列表返回可遍歷的(鍵, 值) 元組數組
7、radiansdict.keys()：以列表返回一個字典所有的鍵
8、radiansdict.setdefault(key, default=None)：和get()類似, 但如果鍵不已經存在於字典中，將會添加鍵並將值設為default
9、radiansdict.update(dict2)：把字典dict2的鍵/值對更新到dict里
10、radiansdict.values()：以列表返回字典中的所有值