python基础知识整理——容器

容器(container)

容器是一种把多个元素组织在一起的数据结构，容器中的元素可以逐个地迭代获取，可以用in, not in关键字判断元素是否包含在容器中。通常这类数据结构把所有的元素存储在内存中（也有一些特例，并不是所有的元素都放在内存，比如迭代器和生成器对象）在Python中，常见的容器对象有：

• list, deque（队列）, ….
• set,（可变集合） frozensets（不可变集合）, ….
• dict, defaultdict(默认字典), OrderedDict(有序字典), Counter（计数器）, ….
• tuple, namedtuple（namedtuple是继承自tuple的子类。namedtuple创建一个和tuple类似的对象，而且对象拥有可访问的属性。）, …
• str

deque（双向队列）

创建一个双向队列

队列方法

• 向右添加——append
• 向左添加——appendleft
• 清空队列
• 浅copy
• 计数——count
• 在队列的左边添加一个元素——extendleft
• 在队列的右边添加一个元素——extend
• 插入某个元素——insert
• 在左边和右边删除某个元素——pop/popleft
• 移除某个指定的元素——remove
• 反转队列元素——reverse
• 把队列右边元素放到左边——rotate

代码示例：

#创建一个队列
>>> import collections
>>> d=collections.deque()
>>> d.append(2)
>>> d
deque([2])
>>> type(d)
<class 'collections.deque'>
>>> d.append('python')
>>> d
deque([2, 'python'])
>>> d.append('a')
>>> d
deque([2, 'python', 'a'])
>>> d.appendleft('hello')
>>> d
deque(['hello', 2, 'python', 'a'])
>>> d.appendleft('python')
>>> d
deque(['python', 'hello', 2, 'python', 'a'])
>>> a=d.copy()
Traceback (most recent call last):
  File "<pyshell#15>", line 1, in <module>
    a=d.copy()
AttributeError: 'collections.deque' object has no attribute 'copy'
>>> a=b
Traceback (most recent call last):
  File "<pyshell#16>", line 1, in <module>
    a=b
NameError: name 'b' is not defined
>>> a=d
>>> a
deque(['python', 'hello', 2, 'python', 'a'])
>>> d
deque(['python', 'hello', 2, 'python', 'a'])
>>> a.clear()
>>> a
deque([])
>>> a.append(11)
>>> a
deque([11])
>>> d
deque([11])
>>> d
deque([11])
>>> a
deque([11])
>>> d
deque([11])
>>> a.count()
Traceback (most recent call last):
  File "<pyshell#28>", line 1, in <module>
    a.count()
TypeError: count() takes exactly one argument (0 given)
>>> count
Traceback (most recent call last):
  File "<pyshell#29>", line 1, in <module>
    count
NameError: name 'count' is not defined
>>> d.count(1)
0
>>> d.count(11)
1
>>> a.extend(1)
Traceback (most recent call last):
  File "<pyshell#32>", line 1, in <module>
    a.extend(1)
TypeError: 'int' object is not iterable
>>> d.extend([1,2])
>>> d.extend(1)
Traceback (most recent call last):
  File "<pyshell#34>", line 1, in <module>
    d.extend(1)
TypeError: 'int' object is not iterable
>>> d.extend('python')
>>> d
deque([11, 1, 2, 'p', 'y', 't', 'h', 'o', 'n'])
>>> d.index(11)
>>> from collections import deque
>>> a=collections.deque()
Traceback (most recent call last):
  File "<pyshell#52>", line 1, in <module>
    a=collections.deque()
NameError: name 'collections' is not defined
>>> a=deque()
>>> a=deque([1,2,3,4,5,6,6,7])
>>> a
deque([1, 2, 3, 4, 5, 6, 6, 7])
>>> a.pop(2)
Traceback (most recent call last):
  File "<pyshell#56>", line 1, in <module>
    a.pop(2)
TypeError: pop() takes no arguments (1 given)
>>> a.pop()
7
>>> a.popleft()
1
>>> 

 namedtuple

>>> from collections import namedtuple
>>> f=nametuple("friend",['name','age','email'])
>>> f=namedtuple("friend",['name','age','email'])
>>> f1=f('小王',33,'[email protected]')
>>> f1
friend(name='小王', age=33, email='[email protected]')
>>> f1.age
33
>>> f1.email
'[email protected]'
>>> f2=f(name='小张',email='xiaozhang',age=30)
>>> f2
friend(name='小张', age=30, email='xiaozhang')
>>> f2.age
30
>>> f2.email
'xiaozhang'
>>> name,age,email=f2
>>> name
'小张'
>>> age
30
>>> email
'xiaozhang'
>>> from collections import namedtuple
>>> def get_name():
	name=namedtuple("namm",['first','middle','last'])
	return name('john','you know nothing','snow')

>>> name=get_name()
>>> name.first
'john'
>>> name.middle
'you know nothing'
>>> name.last
'snow'
>>> 
#我们知道tuple可以表示不变集合，例如，一个点的二维坐标就可以表示成：
>>> p = (1, 2)
1
但是，看到(1, 2)，很难看出这个tuple是用来表示一个坐标的。
定义一个class又小题大做了，这时，namedtuple就派上了用场
#namedtuple实际用法
>>> from collections import namedtuple
>>> p=namedtuple('point'.['x','y'])
>>> p=namedtuple('point',['x','y'])
>>> p1=point(1,2)
Traceback (most recent call last):
  File "<pyshell#63>", line 1, in <module>
    p1=point(1,2)
NameError: name 'point' is not defined
>>> p1=p(1,2)
>>> p.x
<property object at 0x0000000002AEA318>
>>> p.y
<property object at 0x0000000006150A48>
>>> int('p.x',16)

set(可变集合)与frozenset(不可变集合)的区别：

set的特点：

• set无序排序且不重复，是可变的，有add（），remove（）等方法。
• 既然是可变的，所以它不存在哈希值。
• 基本功能包括关系测试和消除重复元素.
• 集合对象还支持union(联合), intersection(交集), difference(差集)和sysmmetric difference(对称差集)等数学运算.
• sets 支持 x in set, len(set),和 for x in set。
• 作为一个无序的集合，sets不记录元素位置或者插入点。因此，sets不支持 indexing, 或其它类序列的操作。

frozenset的特点：

• frozenset是冻结的集合，它是不可变的，存在哈希值，好处是它可以作为字典的key，也可以作为其它集合的元素。
• 缺点是一旦创建便不能更改，没有add，remove方法

set的用法代码示例：

#创建一个集合
>>> a=set('python')
>>> a
{'o', 'y', 'h', 'n', 'p', 't'}
>>> type(a)
<class 'set'>
>>> s=('hello')
>>> s
'hello'
>>> s=(1)
>>> s
1
>>> s=(a)
>>> s
{'o', 'y', 'h', 'n', 'p', 't'}
>>> s
{'o', 'y', 'h', 'n', 'p', 't'}
>>> s=('a')
>>> s
'a'
>>> s
'a'
>>> s=a
>>> s
{'o', 'y', 'h', 'n', 'p', 't'}
>>> t=frozenset(a)
>>> t
frozenset({'t', 'o', 'y', 'n', 'h', 'p'})

 集合的方法

#更新可变集合
>>> s3=set('helol python')
>>> s3
{'o', 'l', 'e', 'y', ' ', 'h', 'n', 'p', 't'}
>>> s3.add(1)
>>> s3
{1, 'o', 'l', 'e', 'y', ' ', 'h', 'n', 'p', 't'}
>>> s3.update('pypi')
>>> s3
{1, 'o', 'l', 'e', 'y', ' ', 'h', 'n', 'i', 'p', 't'}
>>> s3.remove(1)
>>> s3
{'o', 'l', 'e', 'y', ' ', 'h', 'n', 'i', 'p', 't'}
>>> s-=set('pypi')
>>> s3-=set('pypi')
>>> s3
{'o', 'l', 'e', ' ', 'h', 'n', 't'}
>>> del s3('p')
SyntaxError: can't delete function call
>>> del s3
>>> s3
Traceback (most recent call last):
  File "<pyshell#116>", line 1, in <module>
    s3
NameError: name 's3' is not defined
#成员关系 (in, not in)
1 >>> 'k' in s
2 False
3 >>> 'k' in t
4 True
5 >>> 'c' not in t
6 True
#集合等价和不等价（“==”，“！=”）
>>> a=set('mini')
>>> b=set('d')
>>> a==b
False
>>> set('posh')=set('shop')
SyntaxError: can't assign to function call
>>> set('shop')==set('soph')
True
>>> set(python)
Traceback (most recent call last):
  File "<pyshell#122>", line 1, in <module>
    set(python)
NameError: name 'python' is not defined
>>> set(1)
Traceback (most recent call last):
  File "<pyshell#123>", line 1, in <module>
    set(1)
TypeError: 'int' object is not iterable
>>> set('1')
{'1'}
>>> 
#子集和超子集
>>> set('python')<set('hello python')
True
>>> set('python')>=set('p')
True
>>> 
#所有集合类型集合的一些方法
1.len(s) 集合基数: 集合 s 中元素的个数
2.set([obj]) 可变集合工厂函数（使用工厂函数的方法创建一个集合）; obj 必须是支持迭代的，由 obj 中的元素创建集合，否则创建一个空集合。第二种方法创建直接创建s=(obj)
3.frozenset([obj]) 不可变集合工厂函数; 执行方式和 set()方法相同，但它返回的是不可变集合
4.obj in s 成员测试：obj 是 s 中的一个元素吗?
5.obj not in s 非成员测试：obj 不是 s 中的一个元素吗?
s == t 等价测试: 测试 s 和 t 是否具有相同的元素?
s != t 不等价测试: 与==相反
s < t (严格意义上)子集测试; s != t 而且 s 中 所 有 的元素都是 t 的成员
s.issubset(t) s <= t 子集测试(允许不严格意义上的子集): s 中所有的元素都是 t 的成员
s > t (严格意义上)超集测试: s != t 而且 t 中所有的元素都是 s 的成员
s.issuperset(t) s >= t 超集测试(允许不严格意义上的超集): t 中所有的元素 都是 s 的成员
s.union(t) s | t 合并操作： s 或 t 中的元素
s.intersec- tion(t) s & t 交集操作： s 和 t 中的元素
s.difference(t) s - t 差分操作: s 中的元素，而不是 t 中的元素
s.symmetric_difference(t)s ^ t 对称差分操作：s 或 t 中的元素，但不是 s 和 t 共有的元素
s.copy() 复制操作:返回 s 的(浅复制)副本
#可变集合的方法,frozenset不能使用
s.update(t) s |= t (Union) 修改操作: 将 t 中的成员添加 s
s.intersection_update(t) s &= t 交集修改操作: s 中仅包括 s 和 t 中共有的成员
s.difference_update(t) s -= t 差修改操作: s 中包括仅属于 s 但不属于 t 的成员
s.symmetric_
difference_
update(t) s ^= t 对称差分修改操作: s 中包括仅属于 s 或仅属于 t 的成员
s.add(obj) 加操作: 将 obj 添加到 s
s.remove(obj) 删除操作: 将 obj 从 s 中删除；如果 s 中不存在
obj,将引发 KeyError
s.discard(obj) 丢弃操作: remove() 的 友 好 版 本 - 如果 s 中存在 obj,从 s 中删除它
s.pop() Pop 操作: 移除并返回 s 中的任意一个元素
s.clear() 清除操作: 移除 s 中的所有元素

集合类型操作符

>>> s=set('cheeseshop')
>>> t=frozenset('bookshop')
1.联合( | )
1 两个集合的联合是一个新集合，该集合中的每个元素都至少是其中一个集合的成员，即，属于两个集合其中之一的成员。联合符号有一个等价的方法，union().
2 >>> s | t
3 set(['c', 'b', 'e', 'h', 'k', 'o', 'p', 's'])
2.交集( & )
1 你可以把交集操作比做集合的 AND(或合取)操作。两个集合的交集是一个新集合，该集合中的每
2 个元素同时是两个集合中的成员，即，属于两个集合的成员。交集符号有一个等价的方法，intersection()
3 >>> s & t
4 set(['h', 's', 'o', 'p']
3.差补/相对补集( – )
1 两个集合(s 和 t)的差补或相对补集是指一个集合 C，该集合中的元素，只属于集合 s，而不属
2 于集合 t。差符号有一个等价的方法，difference().
3 >>> s - t
4 set(['c', 'e'])
4.对称差分( ^ )
1 和其他的布尔集合操作相似， 对称差分是集合的 XOR(又称"异或 ").
2 两个集合(s 和 t)的对称差分是指另外一个集合 C,该集合中的元素，只能是属于集合 s 或者集合 t
3 的成员，不能同时属于两个集合。对称差分有一个等价的方法，symmetric_difference().
4 >>> s ^ t
5 set(['k', 'b', 'e', 'c'])
5.混合集合类型操作

1 上面的示例中，左边的 s 是可变集合，而右边的 t 是一个不可变集合. 注意上面使用集合操作
2 运算符所产生的仍然是可变集合,但是如果左右操作数的顺序反过来，结果就不一样了:
3 >>> t | s
4 frozenset(['c', 'b', 'e', 'h', 'k', 'o', 'p', 's'])
5 >>> t ^ s
6 frozenset(['c', 'b', 'e', 'k'])
7 >>> t - s frozenset(['k', 'b'])

如果左右两个操作数的类型相同， 既都是可变集合或不可变集合, 则所产生的结果类型是相同
的，但如果左右两个操作数的类型不相同(左操作数是 set，右操作数是 frozenset，或相反情况)，
则所产生的结果类型与左操作数的类型相同。

defaultdict(默认字典), OrderedDict(有序字典), Counter（计数器）

一、defaultdict

 1. 简介

在使用Python原生的数据结构dict的时候，如果用d[key]这样的方式访问，当指定的key不存在时，是会抛出KeyError异常的。但是，如果使用defaultdict，只要你传入一个默认的工厂方法，那么请求一个不存在的key时， 便会调用这个工厂方法使用其结果来作为这个key的默认值。

defaultdict在使用的时候需要传一个工厂函数(function_factory)，defaultdict(function_factory)会构建一个类似dict的对象，该对象具有默认值，默认值通过调用工厂函数生成。

2.代码示例

>>> from collections import defaultdict
>>> a=[('小王',24),('小张',23),('小刘',34),('小李',31),('小董',30),('小丁',27),('小明',28)]
>>> b=defaultdict(list)
>>> for k,v in a:
	d[k].append(v)

	
Traceback (most recent call last):
  File "<pyshell#5>", line 2, in <module>
    d[k].append(v)
NameError: name 'd' is not defined
>>> for k,v in a:
	b[k].append(v)

	
>>> b
defaultdict(<class 'list'>, {'小丁': [27], '小李': [31], '小刘': [34], '小董': [30], '小张': [23], '小王': [24], '小明': [28]})
>>> for k,v in b.items():
	print '%s:%s'%(k,v)
	
SyntaxError: invalid syntax
>>> for k,v in b.items():
	print ('%s:%s'% (k,v))

	
小丁:[27]
小李:[31]
小刘:[34]
小董:[30]
小张:[23]
小王:[24]
小明:[28]
>>> 

对Python比较熟悉的同学可以发现defaultdict(list)的用法和dict.setdefault(key, [])比较类似，上述代码使用setdefault实现如下：

>>> from collections import defaultdict
>>> a=[('小王',24),('小张',23),('小刘',34),('小李',31),('小董',30),('小丁',27),('小明',28)]
>>> d={}
>>> for k,v in a:
	d.setdefault(k,[]).append(v)

	
>>> d
{'小丁': [27], '小李': [31], '小刘': [34], '小董': [30], '小张': [23], '小王': [24], '小明': [28]}
>>> for k,v in d.items():
	print('%s:%s'%(k,v))

	
小丁:[27]
小李:[31]
小刘:[34]
小董:[30]
小张:[23]
小王:[24]
小明:[28]
>>> 
#父类继承的方法
>>> class person:
	def __init__(self,name,age,gender):
		self.name=name
		self.age=age
		self.gender=gender

>>> class student(person):
	def __init__(self,name,age,gender,school,score):
		#super(student,self).__init__(name,age,gender,school,score)
		self.name=name.upper()#大写
		self.age=age
		self.school=school
		self.score=score

		
>>> s=student(name='cai',age=26,gender=3,school='beijing',score=699)

defaultdict在python2.5以后才添加的。

二.Counter

Counter是一个简单的计数器，例如，统计字符出现的个数

>>> import collections
>>> c=Counter()
>>> for ch in 'python':
	c[ch]=c[ch]+1

	
>>> c
Counter({'y': 1, 'p': 1, 'n': 1, 'h': 1, 'o': 1, 't': 1})
>>> for ch in 'hello python':
	c[ch]=c[ch]+1

	
>>> c
Counter({'h': 3, 'o': 3, 'y': 2, 'p': 2, 'n': 2, 'l': 2, 't': 2, ' ': 1, 'e': 1})
>>> 

三.OrderedDict

有序的字典。

>>> import collections
>>> d=collections.OrderedDict
>>> d=OrderedDict()
>>> od=OrderedDict([('name','cai'),('age',26),('gender',5),('sorce',700)])
>>> od
OrderedDict([('name', 'cai'), ('age', 26), ('gender', 5), ('sorce', 700)])
>>> od['address']='beijing'
>>> od
OrderedDict([('name', 'cai'), ('age', 26), ('gender', 5), ('sorce', 700), ('address', 'beijing')])