Python基础第三篇

import collections
a=‘abababsbsbhh‘
c=collections.Counter(a) #直接列出每个元素出现了几次，传入列表和元组也一样
print(c)
#输出：Counter({‘b‘: 5, ‘a‘: 3, ‘h‘: 2, ‘s‘: 2})

#most_common 列出Counter内的前几个
print c.most_common()
print c.most_common(1)
print c.most_common(3)
‘‘‘
输出：
[(‘b‘, 5), (‘a‘, 3), (‘h‘, 2), (‘s‘, 2)]
[(‘b‘, 5)]
[(‘b‘, 5), (‘a‘, 3), (‘h‘, 2)]
‘‘‘

#update 相加
c=collections.Counter(a)
c1=collections.Counter(a)
c.update(c1)
print(c)
#输出：Counter({‘b‘: 10, ‘a‘: 6, ‘h‘: 4, ‘s‘: 4})

#subtract 减
aa=collections.Counter("as")
bb=collections.Counter("htw")
aa.subtract(bb) #c-c1
print(aa)
#输出：Counter({‘a‘: 1, ‘s‘: 1, ‘h‘: -1, ‘t‘: -1, ‘w‘: -1})

#elements  返回包含所有元素集合的迭代器
for item in c.elements():
    print item

import collections
#有序字典，是对字典类型的补充，他记住了字典元素添加的顺序
#具备字典的所有功能 + 自己的功能
dic=collections.OrderedDict()   #定义有序字典
dic["a1"]=1
dic["a2"]=2
dic["a3"]=3
di={}
di["a1"]=1
di["a2"]=2
di["a3"]=3
print(dic)
print(di)
#输出：
# OrderedDict([(‘a1‘, 1), (‘a2‘, 2), (‘a3‘, 3)]) #有序
#{‘a1‘: 1, ‘a3‘: 3, ‘a2‘: 2}    #无序

import collections
#默认字典
#defaultdict    是对字典的类型的补充，他默认给字典的值设置了一个类型。
dic=collections.defaultdict(list) #默认字典的value，也可以是元组(tuple)或字典(dict)
#相当于
dic={}
dic["k1"]=[]

#tupled的扩展
#可命名元组
import collections
t=(1,2)
#创建一个扩展tuple的类，Mytuple
Mytuple=collections.namedtuple(‘Mytuple‘,[‘x‘,‘y‘])
tu=Mytuple(1,2) #相当于给原来的值赋了一个key
print(t)
print(tu)
print tu.x,tu.y
‘‘‘
输出：
(1, 2)
Mytuple(x=1, y=2)
1 2
‘‘‘

#双向队列，两头都可以取可以插
#线程安全
import collections
q=collections.deque() #创建队列
q.append(1)
q.append(2)
q.append(3)
print(q)

#单向队列，一个方向拿
#线程安全
import Queue
q=Queue.Queue(10) #创建队列，指定最多放10个数据
q.put(1)    #进
q.put(2)
q.put(3)
print q.get()   #取
print q.get()
‘‘‘
队列和栈的结构:
    队列：先进先出
    栈：弹夹，后加先出
‘‘‘

‘‘‘
    只能通过循环从迭代器里拿数据
    next方法：返回迭代器的下一个元素
    __iter__方法：返回迭代器
‘‘‘

#生成器:
‘‘‘
    range不是生成器 和 xrange 是生成器
    readlines不是生成器 和 xreadlines 是生成器
     带有 yield 的函数在 Python 中被称之为 generator（生成器）
‘‘‘

for i in range(100): #返回100个元素的列表
    print(i)
for i in xrange(100):#每次迭代中返回一个元素
    print(i)
#生成器只有使用时才创建，从而避免内存浪费

#练习
#下标式循环
‘‘‘
有列表li=[13, 22, 6, 99, 11]
按照以下规则计算：
13 和 22 比较，将大的值放在右侧，即：[13, 22, 6, 99, 11]
22 和 6 比较，将大的值放在右侧，即：[13, 6, 22, 99, 11]
22 和 99 比较，将大的值放在右侧，即：[13, 6, 22, 99, 11]
99 和 42 比较，将大的值放在右侧，即：[13, 6, 22, 11, 99,]
13 和 6 比较，将大的值放在右侧，即：[6, 13, 22, 11, 99,]
‘‘‘
#冒泡算法 依次用下标对应的两个数字进行比较，大的放右边，从而进行排列
li=[13, 22, 6, 99, 11]
aa=(len(li)-1)
while aa>0:
    for m in range(aa):
        if li[m]>li[m+1]:
            temp=li[m]
            li[m]=li[m+1]
            li[m+1]=temp
    aa=aa-1
print(li)
#输出：[6, 11, 13, 22, 99]

#常用内置函数
‘‘‘
基础
    help()
    dir()
    print vars()  当前模块的所有变量
    type()
    reload(temp) 真正的在导入一次一个模块
    id()
    is()
    range
    xrange
计算
    cmp(2,3)
    abs()
    boll()
    divmod()
    max()
    min()
    sum()
    pow(2,11)  2.11次方
    len()
    all() 接受一个序列，如果所有都是真返回真，否则返回假
    any()  只有有一个真就是真
assic码转换
    chr() 接收数字返回字符
    ord() 接收字符返回数字
进制转换
    hex()  10转16
    oct()  10转8
    bin()  10转2
‘‘‘
#enumerate  自动生成一列数字对应列表里的值,从0开始
li=[11,22,33,44]
for k,v in enumerate(li,1):#从1开始
    print(k,v)
‘‘‘
输出：
(1, 11)
(2, 22)
(3, 33)
(4, 44)
‘‘‘