python学习之-影像和集合类型

第七章 ：影像和集合类型

字典是python语言中唯一的映射类型，映射类型对象里哈希值(键,key)和指向的对象(值,value)是一对多的关系。他们与perl中的哈希类型相似。通常被认为是可变的哈希表。一个字典对象是可变的，它是一个容器类型，能存储任意个数的python对象，其中也包括其他容器类型。字典类型和序列类型容器类（列表，元组）的区别似乎存储和房屋数据的方式不同。序列类型只用数字类型的键（从序列的开始起安数值顺序索引）。映射类型可以用其他对象类型做键。
创建字典只需要把字典赋值给一个变量，不管这个字典是否包含元素

dict1 = {}
dict2 = {'name':'earth','port':80}
dict1,dict2
({}, {'name': 'earth', 'port': 80}) # 打印出的结果

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

ddict = {}.fromkeys(('x','y'), -1)
>>> ddict
{'y': -1, 'x': -1}
>>>
>>> edict = {}.fromkeys(('foo','bar'))
>>> edict
{'foo': None, 'bar': None}

如何访问字典中的值？

引用上面的字典dict2

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

下面用for循环来遍历字典，无需上面的keys()方法获取循环使用的键列表了。

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

想要得到某个元素的值，可以用你所熟悉的字典键加上中括号得到

'earth'
>>> print 'host %s is running on port %d' %  (dict2['name'],dict2['port'])
host earth is running on port 80

使用字典的has_key()方法，检查一个字典是否有某个键的最好方法

>>> 'server' in dict2
False
>>> dict2.has_key('server')
False
>>> 'port' in dict2
True
>>> dict2.has_key('port')
True

下面这个例子很搞笑

>>> dict3 = {}
>>> dict3[1] = 'abc'
>>> dict3['1'] = 3.14159
>>> dict3[3.2] = 'xyz'
>>> dict3
{'1': 3.14159, 1: 'abc', 3.2: 'xyz'}
>>> dict3['haha'] = 'sb'
>>> dict3
{'1': 3.14159, 1: 'abc', 'haha': 'sb', 3.2: 'xyz'}
>>>

接下来，如何更新字典了
可以通过下面方法修改字典：添加一个新数据项或新元素(即：一个键值对)；修改

>>> dict2
{'name': 'earth', 'port': 80}   #打印出了dict2中的元素
>>> dict2['name'] = 'venus'        #修改元素name的值为venus
>>> dict2['port'] = 443            #修改元素port的值为443
>>> dict2['arch'] = 'sunos5'    #新增一个元素arch的值为sunos5
>>> dict2
{'arch': 'sunos5', 'name': 'venus', 'port': 443} #再次打印字典dict2

删除字典中的条目

>>> dict2
{'arch': 'sunos5', 'name': 'venus', 'port': 443}
>>> del dict2['name']
>>> del dict2['port']
>>> dict2
{'arch': 'sunos5'}

映射类型操作符

字典可以和所有的标准类型操作符一起工作，但却不支持拼接和重复这样的操作。这些操作对序列有意义，对映射类型行不通。
接下来学习字典中的操作符

标准类型操作符

示例如下：

>>> dict4 = {'abc':123}
>>> dict5 = {'abc':456}
>>> dict6 = {'abc':123,98.6: 37}
>>> dict7 = {'xyz':123}
>>> dict4 <dict5
True
>>> (dict4 <dict6) and (dict4 < dict7)
True
>>> dict6 <dict7
False

映射类型操作符
1.字典的键查找操作符([])
键查找操作符是唯一仅用于字典类型的操作符，它和序列类型里单一元素的切片(slice
) 操作符很相像。对序列类型来说，用索引做唯一参数或下班以获取一个序列中某个元素的值。对字典类型来说，是用键查询（字典中的元素），所以键是参数，而不是一个索引（index）。键查找操作符既可以用于给字典赋值，也可以用于从字典中取值
d[k]v 通过键'k' ,给字典中某元素赋值‘v’
d[k] 通过键‘k’，查询字典中某元素的值

2.键 成员关系操作(in ,not in)

(这里是不是有点重复啊？)

>>> dict2
{'arch': 'sunos5'}
>>> 'name' in dict2
False
>>> 'arch' in dict2
True
>>> 'sunos5' in dict2
False

映射类型的内建函数和工厂函数

标准类型函数[type(),str()和 cmp()]
在字典中调用 type() 工厂方法，会返回字典类型
>>> type(dict2)
<type 'dict'>
str()工厂方法返回该字典字符串表示形式

>>> str(dict2)
"{'arch': 'sunos5'}"
>>> dict2
{'arch': 'sunos5'}

上面给了个双引号，字符串了吧？
字典的比较算法

>>> dict2
{'name': 'zhangsan', 'port': 443}
>>> dict1
{}
>>> cmp(dict1,dict2)
-1
>>> dict1['host']
'zhangshan'
>>> del dict1['host']
>>> dict1
{}
>>> dict1['name'] = 'zhangsan'
>>> dict1
{'name': 'zhangsan'}
>>> dict2
{'name': 'zhangsan', 'port': 443}
>>> cmp(dict1,dict2)
-1

字典的键
字典中的值是没有限制的，键必须唯一，如果键发生冲突，取最近的赋值
python不会因为字典中的键存在冲突而产生一个错误。它不会坚持键的冲突是因为这样做的话，每次赋值都要检查，会占用内存

集合
set称作由不同元素组成的集合，集合(set)的成员通常称作集合元素(set elements）python把这个概念引入到他的集合类型对象里。集合对象是一组无序排列

集合与列表([])和字典({}) 不同 ，没有特别的语法格式，列表和字典都有他们自己的工厂方法 list() dict()创建，这里集合也有自己的工厂方法 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,t)
>>> type(s)
<type 'set'>
>>> type(t)
<type 'frozenset'>
下面进行比较一下
>>> len(s)
6
>>> len(t)
6
>>> len(s) == len(t)
True
>>> s == t
False

可以遍历查看集合成员或者监察某项元素是否是一个集合中的成员

>>> t
frozenset(['b', 'h', 'k', 'o', 'p', 's'])
>>> s
set(['c', 'e', 'h', 'o', 'p', 's'])
>>> 'b' in s
False
>>> 'b' in t
True
>>> for b in t:
print b
b
h
k
o
p
s
>>> for k in t:
print k
b
h
k
o
p
s

如何更新集合？

>>> s
set(['c', 'e', 'h', 'o', 'p', 's'])
>>> t
frozenset(['b', 'h', 'k', 'o', 'p', 's'])
>>> s.add('z')
>>> s
set(['c', 'e', 'h', 'o', 'p', 's', 'z'])
>>> 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('pypio')
>>> s
set(['c', 'e', 'h', 's'])

frozenset 定义的集合是不可变的
那么我们改变集合 t 看能否改变了？

>>> t
frozenset(['b', 'h', 'k', 'o', 'p', 's'])
>>> t.add('a')
Traceback (most recent call last):
File "<pyshell#132>", line 1, in <module>
t.add('a')
AttributeError: 'frozenset' object has no attribute 'add'
>>>

这里报错了啊。哈哈

继续下面的

集合类型操作符

这里我感觉很乱，前面已经操作过了，怎么没有提示?
我的世界里，我想怎么做就怎么做，无需任何理由，这里我想这么写就这么写了
1.成员关系 in , not in
2.集合等价/不等价
3.子集/超集

集合类型操作符
1.联合 |
联合(union)操作和集合的or是等价的，两个集合联合是一个新的集合，该集合中每个元素都至少是其中一个集合的成员，联合符合有一个等价的方法,union()
2.交集(&)
交集可以比作集合的AND操作。两个集合的交集是一个新集合，等价方法是,intersection()
3.差补/相对补集 -
比如两个集合s和t补集后是一个新的集合C那么该集合中的元素属于集合s而不属于后面 的集合t

>>> s
set(['c', 'e', 'h', 's'])
>>> t
frozenset(['b', 'h', 'k', 'o', 'p', 's'])
>>> s -t
set(['c', 'e'])

对称差分(^)
对称差集合，得到新集合只属于集合t或是集合s的成员，有一个等价的方法symmetric_difference()

>>> s
set(['c', 'e', 'h', 's'])
>>> t
frozenset(['b', 'h', 'k', 'o', 'p', 's'])
>>> s ^ t
set(['p', 'b', 'e', 'k', 'c', 'o'])
>>> t ^ s
frozenset(['c', 'b', 'e', 'k', 'o', 'p'])

内建函数
标准类型函数
len()
把集合作为参数传递给内建函数len(),返回集合的基数（或元素的个数）

集合类型工厂函数
set() frozenset()
这两个工厂函数分别用来生成可变和不可变的集合。如果不提供任何参数，默认会生成空集合。如果提供一个参数，则该参数必须是可迭代的，即一个序列，或迭代器，或支持迭代的一个对象，例如一个文件或一个字典
这里只想说，前面用到不写，现在写了有冒用？说明这本书没有其它语言编程基础的人是看的不仅仅吃力，而是吃苦

接下来学习循环了
参考书：python核心编程第二版

这里有人会说，我不在抄书吗？是的，我是在抄书，这样我能加强记忆，也能表示我用心学习技术。技术是低调学习来的