[PYTHON] 核心编程笔记之七-Python映射和集合类型

7.1 映射类型:字典

字典是Python语言中唯一的映射类型,映射类型对象里哈希值(键)和指向的对象(值)是一对多的关系,字典对象可变,它是一个容器类型,能存储任意个Python对象

注:什么是哈希表?
哈希表是一种数据结构:哈希表中存储的每一条数据,叫做一个值(value),是根据与它相关的一个键(key)的数据项进行存储的,键和值合在一起呗称为"键-值 对"
哈希表的算法是获取键,对键执行一个叫做哈希函数的操作,并根据计算结果,在数据结构的某个地址来存储你的值

如何创建字典和给字典赋值:
>>> dict1 = {}
>>> dict2 = {'name':'earth','port':80}
>>> dict1,dict2
({}, {'name': 'earth', 'port': 80})

用工厂方法dict()来创建字典
>>> fdict = dict((['x',1],['y',2]))
>>> fdict
{'y': 2, 'x': 1}

使用内建方法fromkeys()创建一个默认字典
>>> ddict = {}.fromkeys(('x','y'),-1)
>>> ddict
{'y': -1, 'x': -1}
>>> edict = {}.fromkeys(('foo','bar'))
>>> edict
{'foo': None, 'bar': None}

如何访问字典中的值:
>>> dict2 = {'name':'earth','port':80}
>>> for key in dict2.keys():
... print 'key=%s,value=%s' %(key,dict2[key])
...
key=name,value=earth
key=port,value=80

>>> for key in dict2:
... print 'key=%s,value=%s' %(key,dict2[key])
...
key=name,value=earth
key=port,value=80

获取字典某个元素值:
>>> dict2['name']
'earth'
>>> print 'host %s is running on port %d' %(dict2['name'],dict2['port'])
host earth is running on port 80

检查字典中是否有某个键的方法 has_key()或in,not in
>>> 'name' in dict2
True
>>> 'server' in dict2
False
>>> 'name' in dict2
True
>>> dict2['name']
'earth'
>>> dict2.has_key('server')
False
>>> dict2.has_key('name')
True

一个字典中混用数字和字符串的例子:
>>> dict3 = {}
>>> dict3[1] = 'abc'
>>> dict3['1'] = 3.14159
>>> dict3[3.2] = 'xyz'
>>> dict3
{'1': 3.14159, 1: 'abc', 3.2: 'xyz'}

整体赋值:
>>> dict3 = {'1': 3.14159, 1: 'abc', 3.2: 'xyz',33:'hehe'}
>>> dict3
{'1': 3.14159, 1: 'abc', 3.2: 'xyz', 33: 'hehe'}

更新字典:
>>> dict2['name'] = 'venus'
>>> dict2['port'] = 6969
>>> dict2['arch'] = 'sunos5'
>>> print 'host %(name)s is running on port %(port)d' %dict2
host venus is running on port 6969

删除字典元素和字典
>>> dict2
{'arch': 'sunos5', 'name': 'venus', 'port': 6969}
>>> del dict2['name']
>>> dict2
{'arch': 'sunos5', 'port': 6969}
>>> dict2.clear()
>>> dict2
{}
>>> del dict2
>>> dict2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'dict2' is not defined
>>> dict3
{'1': 3.14159, 1: 'abc', 3.2: 'xyz', 33: 'hehe'}
>>> dict3.pop(33)
'hehe'
>>> dict3
{'1': 3.14159, 1: 'abc', 3.2: 'xyz'}

注:避免使用内建对象名字作为变量的标识符
类似: dict,list,file,bool,str,input,len

7.2 映射类型操作符
7.2.1 标准类型操作符
>>> dict4 = {'abc': 123}
>>> dict5 = {'abc': 456}
>>> dict6 = {'abc':123,98.6:37}
>>> dict7 = {'xyz':123}
>>> dict4 < dict5
True
>>> (dict4 < dict6) and (dict4 < dict7)
True
>>> (dict4 < dict6) and (dict5 < dict7)
True
>>> dict6 < dict7
False

7.2.2 映射类型操作符

字典的键超找操作符 ([])
>>> 'name' in dict2
True
>>> 'phone' in dict2
False

7.3 映射类型的内建函数和工厂函数
7.3.1 标准类型函数[type(),str()和cmp()]

字典比较算法
>>> dict1 = {}
>>> dict2 = {'host':'earth','port':80}
>>> cmp(dict1,dict2)
-1
>>> dict1['host'] = 'earth'
>>> cmp(dict1,dict2)
-1
>>> dict1['port'] = 80
>>> cmp(dict1,dict2)
0
>>> dict1['port'] = 'tcp'
>>> cmp(dict1,dict2)
1
>>> dict2['port'] = 'udp'
>>> cmp(dict1,dict2)
-1
>>> cdict = {'fruits':1}
>>> ddict = {'fruits':1}
>>> cmp(cdict,ddict)
0
>>> cdict['oranges'] = 0
>>> cdict['apples'] = 0
>>> cmp(cdict,ddict)
1

7.3.2 映射类型相关的函数

dict()
>>> dict(zip(('x','y'),(1,2)))
{'y': 2, 'x': 1}
>>> dict([['x',1],['y',2]])
{'y': 2, 'x': 1}
>>> dict([('xy'[i-1],i) for i in range(1,3)])
{'y': 2, 'x': 1}

>>> dict(x=1,y=2)
{'y': 2, 'x': 1}
>>> dict8 = dict(x=1,y=2)
>>> dict8
{'y': 2, 'x': 1}
>>> dict9 = dict(**dict8)
>>> dict9
{'y': 2, 'x': 1}

>>> dict9 = dict8.copy()
>>> dict9
{'y': 2, 'x': 1}

len()
>>> dict2 = {'name':'earth','port':80}
>>> dict2
{'name': 'earth', 'port': 80}
>>> len(dict2)
2

7.4 映射类型内建方法
>>> dict2.keys()
['name', 'port']
>>> dict2.values()
['earth', 80]
>>> dict2.items()
[('name', 'earth'), ('port', 80)]
>>> for eachKey in dict2.keys():
... print 'dict2 key',eachKey, 'has value',dict2[eachKey]
...
dict2 key name has value earth
dict2 key port has value 80

字典类型方法

方法名称操作
dict.clear()删除字典里所有元素
dict.copy()返回字典(浅复制)的一个副本
dict.fromkeys(seq,va1=None)创建并返回一个新字典,以seq中的元素做该字典的键,val做该字典中所有键对应的初始值(如果不提供此值,默认为None)
dict.get(key,default=None)对字典dict中的键key,返回它对应的值value,如果字典中不存在此键,则返回 default的值(参数default的默认值为None)
dict.has_key
dict.items()返回一个包含字典中(键,值)对元组的列表
dict,keys()返回一个包含字典中键的列表
dict.iter()
dict.pop(key[,default])如果字典中key键存在,删除并返回dict[key],不存在,且灭有给出没认值,会引发KeyError异常
dict.setdefault(key,default=None) 如果字典不存在key键,由dict[key]=default为它赋值
dict.update(dict2)将字典dict2键值对添加到字典dict
dict.values()返回一个包含字典中所有值的列表

例:
--------------------------------
for eachKey in sorted(dict2):
... print 'dict2 key',eachKey,'has value,dict2[eachKey]'
dict2 key name has value
dict2 key port has value
---------------------------------

update()
----------------------
>>> dict2 = {'host':'earth','port':80}
>>> dict3 = {'host':'venus','server':'http'}
>>> dict2
{'host': 'earth', 'port': 80}
>>> dict2.update(dict3)
>>> dict2
{'host': 'venus', 'port': 80, 'server': 'http'}
>>> dict3.clear()
>>> dict3
{}
-----------------------

copy()
-----------------------
>>> dict4 = dict2.copy()
>>> dict4
{'host': 'venus', 'port': 80, 'server': 'http'}
>>> dict4.get('host')
'venus'
>>> dict4.get('xxx')
>>> type(dict4.get('xxx'))
<type 'NoneType'>
>>> dict4.get('xxx','no such key')
'no such key'
-------------------------

setdefault()
-------------------------------------
>>> myDict = {'host':'earth','port':80}
>>> myDict.keys()
['host', 'port']
>>> myDict.items()
[('host', 'earth'), ('port', 80)]
>>> myDict.setdefault('port',8080)
80
>>> myDict.setdefault('prot','tcp')
'tcp'
>>> myDict.items()
[('host', 'earth'), ('prot', 'tcp'), ('port', 80)]
-------------------------------------

fromkeys()
--------------------------------------
>>> {}.fromkeys('xyz')
{'y': None, 'x': None, 'z': None}
>>> {}.fromkeys(('love','hour'),True)
{'love': True, 'hour': True}
--------------------------------------

7.5 字典的键
7.5.1 不允许一个键对应多个值

>>> dict1 = {'foo':789,'foo':'xyz'}
>>> dict1
{'foo': 'xyz'}
>>> dict1['foo'] = 123
>>> dict1
{'foo': 123}

7.5.2键必须是可哈希的

# vi userpw.py
-----------------------------
#!/usr/bin/env python
db = {}
def newuser():
prompt= 'please regist your name: '
while True:
name = raw_input(prompt)
if db.has_key(name):
prompt = 'name taken,try another: '
continue
else:
break
pwd = raw_input('passswd: ')
db[name] = pwd
print 'Newuser [%s] has added successfully!' %name
def olduser():
name = raw_input('login: ')
pwd = raw_input('passwd: ')
passwd = db.get(name)
if passwd == pwd:
print 'welcome back',name
else:
print 'login incorrect!'

def showmenu():
prompt = """
(N)ew User Login
(E)xisting User Login
(Q)uit
Enter choice: """
while True:
try:
choice = raw_input(prompt).strip()[0].lower()
print '\nYou picked: [%s]' % choice
if choice not in 'neq':
print 'invalid option,please try again'
if choice == 'n':
newuser()
if choice == 'e':
olduser()
if choice == 'q':
break
except(EOFError,KeyboardInterrupt):
print 'invalid option,please try again'

if __name__ == '__main__':
showmenu()
-----------------------------

7.6 集合类型

如何创建集合类型和给集合赋值:
集合与列表和字典不同,没有特别语法格式
用集合的工厂方法可变集合set()和不可变集合frozenset()
>>> s = set('cheeseshop')
>>> s
set(['c', 'e', 'h', 'o', 'p', 's'])
>>> t = frozenset('bookshop')
>>> t
frozenset(['b', 'h', 'k', 'o', 'p', 's'])
>>> type(s)
<type 'set'>
>>> type(t)
<type 'frozenset'>
>>> len(s)
6
>>> len(s) == len(t)
True
>>> s == t
False

如何访问集合中的值:

>>> 'k' in s
False
>>> 'k' in t
True
>>> 'c' not in t
True
>>> for i in s:
... print i
...
c
e
h
o
p
s

如何更新集合:
>>> s.add('z')
>>> s
set(['c', 'e', 'h', 'o', 'p', 's', 'z'])
>>> s.update('pypi')
>>> s
set(['c', 'e', 'i', 'h', 'o', 'p', 's', 'y', 'z'])
>>> s.remove('z')
>>> s
set(['c', 'e', 'i', 'h', 'o', 'p', 's', 'y'])
>>> s -= set('pypi')
>>> s
set(['c', 'e', 'h', 'o', 's'])

只有可变集合能被修改,修改不可变集合会引发异常
>>> t.add('z')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'

删除集合中的成员和集合
>>> del s
>>> s
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 's' is not defined

7.7 集合类型操作符

7.7.1 标准类型操作符(所有的集合类型)
成员关系(in,not in)
>>> s = set('cheeseshop')
>>> t = frozenset('bookshop')
>>> 'k' in s
False
>>> 'k' in t
True
>>> 'c' not in t
True

集合等价/不等价
>>> s == t
False
>>> s != t
True
>>> u = frozenset(s)
>>> s == u
True
>>> set('posh') == set('shop')
True

子集/超集
>>> set('shop') < set('cheeseshop')
True
>>> set('bookshop') >= set('shop')
True

7.7.2 集合类型操作符(所有的集合类型)

联合(|)
等价于or或union()方法
>>> s | t
set(['c', 'b', 'e', 'h', 'k', 'o', 'p', 's'])

交集(&)
等价于and或intersection()方法
>>> s & t
set(['h', 's', 'o', 'p'])

差补
指一个集合,只属于集合s,而不属于集合t
>>> s - t
set(['c', 'e'])

对称差分(^)
指一个集合,只属于集合s或集合t,但不能同时属于两个集合
>>> s ^ t
set(['b', 'e', 'k', 'c'])

7.7.3 集合类型操作符(仅适用于可变集合)
|= 等价于update()

>>> s = set('cheeseshop')
>>> u = frozenset(s)
>>> s |= set('pypi')
>>> s
set(['c', 'e', 'i', 'h', 'o', 'p', 's', 'y'])

7.8 内建函数:
7.8.1 标准类型函数:
len()
把集合作为参数传递给内建函数len(),返回集合的基数(或元素的个数)
>>> s = set(u)
>>> s
set(['p', 'c', 'e', 'h', 's', 'o'])
>>> len(s)
6

7.8.2集合类型工厂函数
set() and frozenset()

>>> set()
set([])
>>> set([])
set([])
>>> set(())
set([])
>>> set('shop')
set(['h', 's', 'o', 'p'])
>>> frozenset(['foo','bar'])
frozenset(['foo', 'bar'])
>>> f = open('numbers','w')
>>> for i in range(5):
... f.write('%d\n' %i)
...
>>> f.close()
>>> f = open('numbers','r')
>>> set(f)
set(['0\n', '3\n', '1\n', '4\n', '2\n'])
>>> f.close()

7.9.1 方法
7.9.2 方法(仅适用于可变集合)
7.9.3 操作符和内建方法比较

方法名操作
s.update(t)用t中的元素修改s,即s包含s或t的成员
....
s.add(obj)在集合s中添加对象obj
s.remove(obj)从集合s中删除对象obj,如果obj不是集合s中的元素,将引发keyError错误
s.discard(obj)如果obj是集合s中的元素,从集合s中删除对象obj
s.pop()删除集合s中任意一个对象,并返回它
s.clear()删除集合s中的所有元素

7.10 操作符,函数/方法

7.11 相关模块

.....