python培训Day3 随笔
collections类
这个类相当于一个扩展包，包含针对字典、列表、元组等数据类型的一些扩展操作。
1、计数器Counter
#计数器可以列出字符串和列表中元素出现的个数，并以字典返回
>>> import collections
>>> li=['a','b','a','c','a','b','d','d','a']
>>> st='asdasdasdasdasda'
>>> li_c=collections.Counter(li)
>>> st_c=collections.Counter(st)
>>> print li_c
Counter({'a': 4, 'b': 2, 'd': 2, 'c': 1})
>>> print st_c
Counter({'a': 6, 's': 5, 'd': 5})
#通过most_comm()方法可以指定显示出现次数排名前n位的元素
>>> print li_c.most_common(3)
[('a', 4), ('b', 2), ('d', 2)]
#update()方法可以将两个计数器的统计结果相加
>>> import collections
>>> li_a=['a','b','a','c','a']
>>> li_b=['b','c']
>>> li_a_co=collections.Counter(li_a)
>>> li_b_co=collections.Counter(li_b)
>>> print li_a_co
Counter({'a': 3, 'c': 1, 'b': 1})
>>> print li_b_co
Counter({'c': 1, 'b': 1})
>>> li_a_co.update(li_b_co)
>>> print li_a_co
Counter({'a': 3, 'c': 2, 'b': 2})
2、有序字典
#有序字典的的操作方法和标准字典完全一致，唯一的区别就是有序字典里的key是可以按照顺序展现出来的，这是因为有有序字典其实就是在标准字典的基础上又将key都存入了一个列表，通过列表管理key
>>> import collections
>>> ord_dic=collections.OrderedDict()
>>> ord_dic={}
3、默认字典
#标准字典中value的值数据类型是需要提前定义的，否则直接向value中添加数据就可能有问题。例如如下需求：
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
即： {'k1': 大于66 , 'k2': 小于66}
#传统实现方式
li=[11,22,33,44,55,66,77,88,99,90]
list_a=[]
list_b=[]
dic={'k1':list_a,'k2':list_b}
for i in li:
if i > 66:
dic['k1'].append(i)
else:
dic['k2'].append(i)
print dic
#用默认字典方式
import collections #coding:utf-8 li=[11, 22, 33,44,55,66,77,88,99,90] #用默认字典方法提前定义value的数据类型 dic=collections.defaultdict(list) for value in li: if value>66: dic['k1'].append(value) else: dic['k2'].append(value) print dic
队列
#队列分为双向队列和单向队列，所有的队列都是有进程安全的。
双向队列是队列两边都可以增减操作，是FIFO模式的
单向队列只有一边可以增减操作，所以单向队列就是个堆栈。
这部分以后会用到，现在暂时知道原理就好了。
文件的处理
#文件处理的流程一般是
打开文件->操作文件->关闭文件
一、打开文件
f=open('文件名'，'打开模式')
打开文件的模式有：
r，只读模式（默认）。
w，只写模式。【不可读；不存在则创建；存在则删除内容；】
a，追加模式。【可读； 不存在则创建；存在则只追加内容；】
"+" 表示可以同时读写某个文件
r+，可读写文件。【可读；可写；可追加】
w+，无意义
a+，同a
"U"表示在读取时，可以将 \r \n \r\n自动转换成 \n （与 r 或 r+ 模式同使用）
rU
r+U
"b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）
rb
wb
ab
文件的处理
flush()
#flush方法可以将缓存中的内容刷写到硬盘上，但是还要考虑的是这个刷写只是涉及python的缓存，至于到底什么时候才能真的写到硬盘上。还得看系统缓存。
f=open('test.txt','w')
f.write('aaaa')
f.flush()
f.close
read(),readline(),readlines()
#read(),readline(),readlines()方法的区别是
read(n)是一次性把问文件内容读入内存，n表示每次要读入的字节数，默认是读取所有数据
>>> f=open('test.txt','r')
>>> x=f.read()
>>> f.close()
>>> x
'1 213123123\n2 123123123123\n3 1231231231231\n4 23123123123123\n5 123123123123123\n'
readlines()是一次性把文件内容读入内存，并将源文件中每一行的内容读入列表作为一个元组
[wgw@mail ~]$ cat test.txt 1 213123123 2 123123123123 3 1231231231231 4 23123123123123 5 123123123123123
使用readliness读取的结果为
f=open('test.txt','r')
x=f.readlines()
f.close()
print x
['1 213123123\n', '2 123123123123\n', '3 1231231231231\n', '4 23123123123123\n', '5 123123123123123\n']
readline()是每次只把源文件中的一行读入内存中
f=open('test.txt','r')
x=f.readline()
f.close()
print x
1 213123123
还一个xreadline()的方法是每次读取一行到内存中，并打印出来一行的内容。之后
依次循环知道所有内容都打印完，这样就避免超大文本的读取的时候直接把内存撑爆。
不过现在这个方法已经被废弃，取而代之的是直接for循环句柄的方式来读取
f=open('test.txt','r')
for line in f:
print line
f.close()
1 213123123 2 123123123123 3 1231231231231 4 23123123123123 5 123123123123123
next()
#读取下一行数据，若没有则触发StopIteration的异常
f=open('test.txt','r')
for i in range(3):
x=f.next()
print x
f.close()
1 213123123 2 123123123123 3 1231231231231
seek()
#表示调整当前读取一行数据的位置指针，默认都是每一行的第一个字节开始读取。但是如果
读取第二个字节以后的内容就需要通过seek()方法调整指针的读取位置
[wgw@mail ~]$ cat test.txt 1122334455
f=open('test.txt','r')
#从第二个字节开始向后读
f.seek(2)
x=f.readline()
print x
f.close()
[wgw@mail ~]$ python test.py 22334455
tell()
#返回目前指针的读取位置
#!/usr/bin/env python
#-*-coding:utf8-*-
f=open('test.txt','r')
position=f.tell()
print '起始的指针位置：',position
f.seek(2)
position=f.tell()
print '调整后的指针位置：',position
x=f.readline()
print x
position=f.tell()
print '读完一行最后的指针位置：',position
f.close()
[wgw@mail ~]$ python test.py 起始的指针位置： 0 调整后的指针位置： 2 22334455 读完一行最后的指针位置： 11
truncate(n)
#截取字符串，只保留指定的指针位置n之前的字符串，其余的全部删除并将结果写回到源文件。
#!/usr/bin/env python
#-*-coding:utf8-*-
#打开方式必须是可读写的r+
f=open('test.txt','r+')
#从f1文件的第二个字节位置开始截取
f.truncate(2)
print f.readlines()
f.close
[wgw@mail ~]$ cat test.txt 11
write()
#写入一个字符串到文件中
>>> f=open('test.txt','w')
>>> f.write('wgw')
>>> f.close()
[wgw@mail ~]$ cat test.txt wgw
writelines()
#将字符串，列表，字典等数据类型一次性写入文件中。当列表中必须都是字符串，而写入字典的话讲只有key值看不到value值
#!/usr/bin/env python
#-*-coding:utf8-*-
test_list=['1','a','b','c','\n']
test_dic={'k1':'10cc','k2':20}
f=open('test.txt','a')
f.writelines(test_list)
f.writelines(test_dic)
f.close()
[wgw@mail ~]$ cat test.txt 1abc k2k1
with
#普通的打开文件方式每次都要调用close()方法关闭文件。使用with方法打开文件就可以自动关闭文件
with open('test.txt','a') as f:
x=f.read()
print x
并且用with方法可以同时打开多个文件
with open('test.txt','a') as f1,open('wgw.txt','r') as f2:
函数
函数的作用是将代码模块化，使同一功能的代码可以被反复调用
函数分为三大类：
一、内置函数
内置函数是python自身就集成好的功能模块，需要熟知的内置函数如下
help()
dir()
vars()
type()
reload(temp)
id([12])
is
------------------
cmp(2,3)
abs()
bool()
divmod(10，3),分页
max()
min()
sum()
pow(2, 11) 求幂 <==> 2**11
------------------
len()
all() 接受一个序列，判断，所有值都是真，返回真，否则假
any() 接受一个序列，判断，只要有一个值为真，返回真，否则假
------------------
chr()
ord()
hex()
oct()
bin()
------------------
print range(10)
print xrange(10)
for i in xrange(10):
print i
for k,v in enumerate([1,2,3,4]，执行数字起始值):
print k,v
二、自定义函数
#当python自身提供的函数不能满足需求的时候，就可以自己定义函数
格式如下
1、def 定义函数的关键字
2、函数名，日后通过函数名调用该函数
3、函数声明，不自动执行；调用后才执行 if __name__='main':
4、函数的参数
5、函数的返回值
#!/usr/bin/env python #coding:uft-8 def myfunc(x,y): return x+y w=myfunc(1,2) 3
返回值：
1、未明确制定返回值，返回 None
2、返回值可以赋值给某个变量
其中括号中的内容就是函数的参数,参数的分类如下：
1）普通参数
如上面列子中展示的x,y就是定义的普通的参数
2）默认参数
默认参数的意思就是在定义参数的时候给参数提供一个默认值，如果有新的值赋进来就用新的值。如果没有新值就用采用默认参数。但是要注意：1、不传，则使用默认 2、默认参数必须放在参数列表的最后
def myfunc(x,y=5): return x+y w=myfunc(1,2) #第二次调用的时候，只给x赋值为1而没有指定y参数的值 z=myfunc(1) print w print z 3 6
3）动态参数
普通参数和默认参数只能传入一个数字或者字符串，当我们要传入一个列表或者字典的时候就需要用到
动态参数
1、当需要传入一个列表的时候，在定义参数的时候要用一个*号和args表示要引用列表
def myfunc(*args):
print args
li=['aa','bb','cc']
myfunc(*li)
#或者用myfunc(aa,bb,cc）方式执行
('aa', 'bb', 'cc')
2、当要传入一个字典的时候，在定义参数的时候要用两个个*号和kwargs表示要引用字典
def myfunc(**kwargs):
print kwargs
dic={'aa':11,'bb':22,'cc':33}
myfunc(**dic)
#或者用myfunc(aa=11,bb=22,cc=33)方式调用，但是注意只能用=号连接k,v值
{'aa': 11, 'cc': 33, 'bb': 22}
3、当传入的参数即有可能是列表也有可能是字典的时候，就需要将两种设置方式都写入函数中。
函数在调用的时候会自动判断传入的数据类型
只传入列表
def myfunc(*args,**kwargs):
print args
print kwargs
li=[77,88,99]
dic={'aa':11,'bb':22,'cc':33}
myfunc(*li)
(77, 88, 99)
{}
只传入字典
def myfunc(*args,**kwargs):
print args
print kwargs
li=[77,88,99]
dic={'aa':11,'bb':22,'cc':33}
myfunc(**dic)
()
{'aa': 11, 'cc': 33, 'bb': 22}
既有列表又有字典
def myfunc(*args,**kwargs):
print args
print kwargs
li=[77,88,99]
dic={'aa':11,'bb':22,'cc':33}
myfunc(*li,**dic)
(77, 88, 99)
{'aa': 11, 'cc': 33, 'bb': 22}
三、第三方函数和模块
第三方函数和模块主要是指从网上下载的别人写好的函数 通过import导入之后使用的函数
本文出自 “霹雳豆包” 博客，谢绝转载！