Python之collections序列迭代器下标式循环冒泡算法等

 

练习题

元素分类

有如下值集合[11,22,33,44,55,66,77,88,99]将所有大于66的数作为一个列表放在字典的key为k1的value小于等于66的为k2的value

{'k1':[77,88,99],'k2':[11,22,33,44,55,66]}

脚本vim day3-1

#!/usr/bin/python
# -*- coding:utf-8 -*-
number_list = [11,22,33,44,55,66,77,88,99]
number_dict = {'k1':[],'k2':[]}
for i in number_list:
　　if i<66:
　　　　number_dict['k1'].append(i)
　　else:
　　　　number_dict['k2'].append(i)
print number_dict

执行

以上是针对知道key的假如不清楚key或者是key需要在一个文件中读取呢

修改代码

#!/usr/bin/python
# -*- coding:utf-8 -*-
number_list = [11,22,33,44,55,66,77,88,99]
#number_dict = {'k1':[],'k2':[]}
number_dict = {}
for i in number_list:
　　if i<66:
　　　　if "k1" in number_dict.keys():
　　　　　　number_dict['k1'].append(i)
　　else:
　　　　number_dict['k1']=[i,]
else:
　　if "k2" in number_dict.keys():
　　　　number_dict['k2'].append(i)
　　else:
　　　　number_dict['k2']=[i,]
print number_dict

先把字典定义为空,然后在第一次的时候增加key,运行结果是一样的

 

假如需要读取文件

log内容为

alex|123|1
eric|123|1
tony|123|1

编辑脚本day3-2.py

#!/usr/bin/python
# -*- coding:utf-8 -*-
obj = file('log','r')
line_list = obj.readlines()
#line_list=['alex|123|1\n', 'eric|123|1\n', 'tony|123|1\n']
obj.close()
dic = {}
for line in line_list:
　　line = line.strip()
#line=['alex|123|1']
　　ele_list = line.split('|')
#ele_list=['alex','123','1']
　　dic[ele_list[0]] = ele_list[1:]
print dic

执行

 

collection系列(对字典的补充)

1,计数器

>>> c1 = collections.Counter('asjdhadhwjke')
>>> c1
Counter({'a': 2, 'd': 2, 'h': 2, 'j': 2, 'e': 1, 'k': 1, 's': 1, 'w': 1})

传递一个序列计算出字符出现的次数

>>> c1 = collections.Counter('aabc')
>>> c1
Counter({'a': 2, 'c': 1, 'b': 1})
>>> c2 = collections.Counter('aab')
>>> c1.update(c2)
>>> c1
Counter({'a': 4, 'b': 2, 'c': 1})

更新了重复叠加

 

>>> c1['a']

4

>>> c1['o']
0

对于不存在的返回0

 

>>> c1.most_common(1)
[('a', 3)]
>>> c1.most_common(2)
[('a', 3), ('j', 3)]
>>> c1.most_common(3)
[('a', 3), ('j', 3), ('d', 2)]
>>> c1.most_common(4)
[('a', 3), ('j', 3), ('d', 2), ('k', 2)]
>>> c1.most_common(5)
[('a', 3), ('j', 3), ('d', 2), ('k', 2), ('l', 1)]
>>> c1.most_common(6)
[('a', 3), ('j', 3), ('d', 2), ('k', 2), ('l', 1), ('s', 1)]
>>> c1.most_common(7)
[('a', 3), ('j', 3), ('d', 2), ('k', 2), ('l', 1), ('s', 1)]

显示前几个,如果大于最大的则显示全部

 

>>> c1.elements()
<itertools.chain object at 0x7f003cc7fc10>
>>> for item in c1.elements():
... print item
...
a
a
a
d
d
k
k
j
j
j
l
s

取出里面所有元素,需要使用循环才能全部取出

 

>>> li = [11,22,33,44,55,11,44,55]
>>> c1 = collections.Counter(li)
>>> c1
Counter({11: 2, 44: 2, 55: 2, 33: 1, 22: 1})

也可以统计列表(元祖)里面的元素出现的次数

PS:Counter其实可以理解为一个内部的循环记录到字典里面

 

2,有序字典

对字典的补充,他记录了字典添加是顺序

>>> o1 = collections.OrderedDict()
>>> o1
OrderedDict()

和字典是一样的不同的是有序,其实是在内部维护了一个有序的列表

 

3,默认字典

字典的value设置一个默认的类型,可以是str,list,dict等

my_dict = collections.defaultdict(list)

 PS:使用默认字典可以使用一下简单代码就能实现脚本day3-2.py的功能

 

4,可命名元祖

   .创建类

　.使用类创建对象

   .使用对象

>>> old = (1,2)
>>> old
(1, 2)

Mytuple = collections.namedtuple('Mytuple',['x','y'])

n = Mytuple(1,2)
>>> n
Mytuple(x=1, y=2)

>>> n.x
1
>>> n.y
2

PS:元祖是通过下标来访问,这个可以通过命名访问,用的最多的是用来定义坐标

 

5,双向队列(deque)

可以两头取数据及插入数据

线程安全

>>> q=collections.deque()
>>> q.append(1)
>>> q.append(11)
>>> q.append(13)
>>> q.append(12)
>>> q
deque([1, 11, 13, 12])
>>> q.pop()
12
>>> q
deque([1, 11, 13])

 

6,单向队列

只能是从一端操作(生产者消费者模型)

>>> q = Queue.Queue(10)
>>> q
<Queue.Queue instance at 0x7f773fa79368>
>>> type(q)
<type 'instance'>
>>> q.put(1)
>>> q.put(2)
>>> q.put(3)
>>> q
<Queue.Queue instance at 0x7f773fa79368>
>>> q.get()
1
>>> q.get()
2
>>> q.get()
3
>>> q.get()

一个个使用put放入使用get取出,先进先出

队列,FIFO先进先出

栈,弹夹,后进的先出

 

迭代器和生成器

迭代器是通过循环按顺序返回值

>>> import collections
>>> c1 = collections.Counter('1112312312sdfsdf')
>>> c1
Counter({'1': 5, '2': 3, 'd': 2, 'f': 2, 's': 2, '3': 2})
>>> c1.elements()
<itertools.chain object at 0x7fba6cdc2d10>
>>> d1=c1.elements()
>>> d1
<itertools.chain object at 0x7fba6cdae910>

直接是无法取值的只能通过循环方式取出

>>> for i in d1:
... print i
...
d
d
f
f
s
s
1
1
1
1
1
3
3
2
2
2

要实现迭代类里面要有某一个方法(next)

 

生成器

range()不是生成器xrange是生成器

readlines()不是生成器xreadlines()是生成器

>>> a=range(10)
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b=xrange(10)
>>> b
xrange(10)
>>> type(a)
<type 'list'>
>>> type(b)
<type 'xrange'>

>>> for i in a:
... 　　 print i
...
0
1
2
3
4
5
6
7
8
9
>>> for i in b:
... 　　 print i
...
0
1
2
3
4
5
6
7
8
9

range()是直接在内存创建xrange()是在使用是时候才创建

 

下标循环

>>> li = [11,22,33,44,55,66]
>>> for i in li:
... 　　 print i
...
11
22
33
44
55
66

也可以通过下标实现循环,效果是一样的

>>> for i in range(len(li)):
... 　　 print li[i]

练习

li = [13,22,6,99,11]

怎么通过循环使列表数组按从小到大排序

li = [13,22,6,99,11]
　　for m in range(len(li)-1):
　　　　if li[m] > li[m+1]:
　　　　temp = li[m]
　　　　li[m] = li[m+1]
　　　　li[m+1] = temp
print li

[13, 6, 22, 11, 99]

循环一次99放到最后了

再循环一次,22就放到倒数第二位了 这就叫冒泡算法(下周继续讲)