python 下标循环_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()

>>> 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

>>> type(q)

>>> q.put(1)

>>> q.put(2)

>>> q.put(3)

>>> q

>>> 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()

>>> d1=c1.elements()

>>> d1

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

>>> 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(b)

>>> 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就放到倒数第二位了 这就叫冒泡算法(下周继续讲)