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导入之后使用的函数