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()：以列表返回字典中的所有值