Python基础第三篇

一、collections系列

Counter是对字典类型的补充，用于追踪值的出现次数，具备字典的所有功能 + 自己的功能

1.计数器Counter

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

Counter

2、有序字典(orderedDict )

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}    #无序

3、默认字典(defaultdict)

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

4、可命名元组

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

5、双向队列、单向队列

#双向队列，两头都可以取可以插
#线程安全
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()
‘‘‘
队列和栈的结构:
    队列：先进先出
    栈：弹夹，后加先出
‘‘‘

二、迭代器和生成器

1.迭代器

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

2.生成器

#生成器:
‘‘‘
    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]

三、函数

1.内置函数

常用内置函数

#常用内置函数
‘‘‘
基础
    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)
‘‘‘

每个文件模块自己的变量

#__file__
print __file__  #当前文件路径

#__doc__
import index
print index.__doc__ #index是模块名，可查看一个文件模块的顶部注释

#__name__  用来判断是不是程序的主文件
#当主程序执行时__name__="__main__"
if __name__=="__main__":
    pass

2.自定义函数

　　def 函数名(参数):

   　　 函数体

1.return 当函数执行完毕后，可以给调用者返回数据

2.参数

　　普通参数：参数可以有n个，但必须传入指定个数的参数

　　默认参数：如果默认参数不传值，则使用默认值，并且默认参数只能放在最后

　　动态参数：

　　　　动态参数一：*args

#接受多个参数,内部自动构造元组
#传入序列要加*，避免内部构造元组
li=[11,22,33]
def func(*args):
    print(args)
func(li)    #把传的列表当成元组的元素
func(*li)   #加*把传的列表内的每个元素当成元组的元素
#输出：
#([11, 22, 33],)
#(11, 22, 33)

　　　　动态参数二：**kwargs

#构造字典(两*)
dic={"a":1,"b":2}
def func1(**kwargs):
    print(kwargs)
func1(a=11)
func1(**dic)
#输出：
#{‘a‘: 11}
#{‘a‘: 1, ‘b‘: 2}

结合上面两种：

def func2(*args,**kwargs):
    print(args)
    print(kwargs)
func2(1,2,3,a=1,b=2)
#输出：
#(1, 2, 3)
#{‘a‘: 1, ‘b‘: 2}

四、文件操作

1.打开文件

文件句柄 = file(‘文件路径‘, ‘模式‘)

模式：

‘‘‘
r   只读模式
w   只写模式(不可读,不存在则创建,存在则删除内容)
a   追加模式(可读,不存在则创建,存在则只追加内容)
"+" 表示可以同时读写某个文件

r+  可读写文件(可读,可写,可追加)
w+  写读
a+  同a

rU  表示在读取时，可以将 \r \n \r\n自动转换成 \n （只能与r或r+模式一起使用）

"b" 表示处理二进制文件
rb  以2进制方式去读取文件
wb
ab
‘‘‘

2.操作文件

‘‘‘
close()     关闭文件
fileno()    文件描述符
flush()     刷新文件内部缓冲区
isatty()    判断文件是否是同意tty设备
next()      获取下一行数据，不存在，则报错
read()      读取指定字节数据
readline()  仅读取一行数据
readlines() 读取所有数据，并根据换行保存到列表
xreadlines()可用于逐行读取文件，非全部
seek()      指定文件中指针位置
tell()      获取当前指针位置
truncate()  截断指针后面的内容只留前面的
write()     写
writelines()将一个字符串列表写入文件
‘‘‘

with

　　为了避免打开文件后忘记关闭,当with代码块执行完毕时，内部会自动关闭并释放文件资源

with open(‘‘,‘r‘) as obj:
    obj.read()

Python 2.7后with还支持多个文件管理

with open(‘‘,‘r‘) as obj1,open(‘‘) as obj2:
    pass