collection系列 （关于字典的统计系列）
1.计数器（counter）功能
import collections
a = collections.Counter("sfsaf") #统计字符出现次数(也可以放入字典的值values)
a[‘a‘] #输出一个元素出现的数量
a.elements()查看所有内容 #只能通过循环的方式读出所有值，返回迭代器，内存地址
dica.update(dicb) #可以将字典b中的内容更新到字典a中
dica.clear() #清空字典
dica.most_common(2) #排序之后输出前2位
2.有序字典(orderedDict ) 排序功能 orderdDict是对字典类型的补充，它记住了字典元素添加的顺序
a = collections.OrderedDict(list)
3.默认字典(defaultdict) 功能 是对字典的类型的补充，他默认给字典的值设置了一个类型。
#1
my_dict = collections.defaultdict(list) #字典里的value设置默认类型
dic[‘k1‘].append(1)
有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
即： {‘k1‘: 大于66 , ‘k2‘: 小于66}
方法1
#!/usr/bin/env python
# -*- coding:utf-8 -*-
a = [11,22,33,44]
b = defaultdict(list)
for i in a:
if i>22:
b[‘k2‘].append(i)
else:
b[‘k1‘].append(i)
print b
#2(楼上省去一个步骤而已)
dic= {}
dic[‘k1‘] = []
dic[‘k1‘].append(1)
方法2
#!/usr/bin/env python
# -*- coding:utf-8 -*-
a = [11,22,33,44,55]
b_dic = {}
for i in a:
if i > 33:
if ‘k2‘ in b_dic.keys():
b_dic[‘k2‘].append(i)
else:
b_dic[‘k2‘] = [i,]
else:
if ‘k1‘ in b_dic.keys():
b_dic[‘k1‘].append(i)
else:
b_dic[‘k1‘] = [i,]
print b_dic
4.可命名元组(namedtuple)
根据nametuple可以创建一个包含tuple所有功能以及其他功能的类型。
1.创建类
2.使用类创建对象
3.使用对象
import collections
Mytuple = collections.namedtuple(‘Mytuple‘,[‘x‘, ‘y‘, ‘z‘])
new = Mytuple(1,2,3)
new.x
help(Mytuple )子类继承父类所有拓展功能
1.直接使用类创建对象
2.使用对象
Li = list(1,2,3,4)
print Li
5、双向队列(deque)
一个线程安全的 双向队列 左右开弓两头可取
import collections
q = collections.deque()
q.append(1)
q.append(2)
q (直接查看)
q.pop()：默认右侧取出 打印出最后一个并删除
q.popleft()：左侧取出
q 就没有了最后一个
help(collections.deque)使用help进行查询
5.1单向队列 别称为叫生产者消费者模型 栈：后进先出 结构被称为弹夹
import Queue 模块调用
import Queue
q = Queue.Queue(10) 10为存放的长度
q.put(1) 存入
q.get() 取出
6.迭代器
d1 = cl.elements() d1就为一个迭代器
只有迭代的时候才能去拿值
迭代器内部每一次都会执行next()方法
6.1生成器
range不是生成器 和 xrange 是生成器
readlines不是生成器 和 xreadlines 是生成器
数值左移
#!/usr/bin/env python
# -*- coding:UTF-8 -*-
li = [13, 22, 6, 99, 11]
for m in range(len(li)-1):
print m
for n in range(m+1, len(li)):
print n
if li[m]> li[n]:
temp = li[n]
li[n] = li[m]
li[m] = temp
print li
Python之路【第三篇】：Python基础（二）参考于
1.内置函数（常用函数部分介绍注释）
vars() = 当前模块的所有变量
为了使用方便，相当于快捷方式
print vars() 取出当前模块的所有变量
print __file__
print ___doc__
print __name__
file() 取文件的路径
doc() 打印注释
name() 被执行的脚本 name=main、package()
abs() 函数返回()内数字的绝对值
print "abs(-45) : ", abs(-45)
print "abs(119L) : ", abs(119L)
help(list) 详细列出所有详细功能
help(类型名,功能名) 详细列出单个内容的详细功能
dir(list) 查看类中提供的所有功能
import sys
reload(sys) 重新加载模块用于调试使用
id([a]) 查看变量内存地址用于相互比较地址
cmp(2,3) 函数用于比较2个对象，如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。
max() 返回给定参数的最大值，参数可以为序列
min() 返回给定参数的最小值，参数可以为序列
print "max(80, 100, 1000) : ", max(80, 100, 1000)
sum() 求和功能参数
sum([1,2,3])
sum(range(1,11))
还有一个比较有意思的用法
a = range(1,11)
b = range(1,10)
c = sum([item for item in a if item in b])
print c
divmod(10,3) 方法返回的是a//b（除法取整）以及a对b的余数
pow(100,2) 幂返回 xy（x的y次方） 的值。 pow()是不能直接访问的，需要导入 math 模块
all([‘a‘, ‘b‘, ‘c‘, ‘d‘]) 接收一个序列进行判断，若所有值为真，则返回真，否则返回假 相当于 and逻辑与的关于
any([‘a‘, ‘‘] ) 接受一个序列，判断，只有有一个值为真 则就为真 or逻辑或的关系
len(a) 显示字符长度
chr() 接收一个数字返回字符 取值范围[0, 255]之间的正数
ord() 接收一个字符返回数字
通过chr()和ord()联合起来使用，我们就可以对字符串进行相关运算的转换
比如一个字符串str1，转化成另一个字符串str2， 使得 str2[i] = str1[i] - i
str1 = "eb;3ej8h"
>>> for i in range(0, len(str1)):
... print chr((ord(str1[i])-i)),
...
e a 9 0 a e 2 a
oct(12) 八进制转换
bin(9) 二进制转换
hex(2) 十六进制转换
range(10) 造数功能，像shell下的seq
xrange() 是一个类，返回的是一个xrange对象。使用xrange()进行遍历，每次遍历只返回一个值。range()返回的是一个列表，一次性计算并返回所有的值。因此，xrange()的执行效率要高于range()enumerate(li,1)执行数字起始值
map(None,list1) 对可迭代函数‘iterable‘中的每一个元素应用‘function’方法，将结果作为list返回
deduce() 计算和
sum=reduce(lambda x,y:x+y,(1,2,3,4,5,6,7))
print sum
apply() apply(func [, args [, kwargs ]]) 函数用于当函数参数已经存在于一个元组或字典中时，间接地调用函数。args是一个包含将要提供给函数的按位置传递的参数的元组。如果省略了args，任何参数都不会被传递，kwargs是一个包含关键字参数的字典
filter() filter()函数可以对序列做过滤处理，就是说可以使用一个自定的函数过滤一个序列，把序列的每一项传到自定义的过滤函数里处理，并返回结果做过滤。最终一次性返回过滤后的结果。
zip() zip函数接受任意多个（包括0个和1个）序列作为参数，返回一个tuple列表
x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
xyz = zip(x, y, z)
u = zip(*xyz)
print u
运行的结果是：
[(1, 2, 3), (4, 5, 6), (7, 8, 9)]
一般认为这是一个unzip的过程，它的运行机制是这样的：
在运行zip(*xyz)之前，xyz的值是：[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
那么，zip(*xyz) 等价于 zip((1, 4, 7), (2, 5, 8), (3, 6, 9))
所以，运行结果是：[(1, 2, 3), (4, 5, 6), (7, 8, 9)]
2.自定义函数
2.1def 定义函数的关键字
面向过程编程，即:根据业务逻辑从上到下实现功能，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是复制粘贴，也就是将之前的代码复制到现在需要的功能处，这个是比较笨的方式。
while True:
if cpu使用率 > 90%:
#发送报警提醒
发邮件短信
if cpu使用率 > 90%:
#发送报警提醒
发邮件短信
函数式编程:将某功能代码封装到函数中function，日后便无需重复编写，仅仅是调用函数即可，后者必然比第一种的重用性和可读性要优秀很多。
def 发送邮件(内容)
#发送报警提醒
发邮件短信
while True:
if cpu使用率 >90%:
发送邮件(‘cpu报警‘)
2.2函数名，函数的使用和定义，日后通过函数名调用该函数
函数声明，不自动执行 调用后才执行
函数式编程最重要的是增强代码的重用性和可读性
def 函数名(参数):
...
函数体
...
函数定义主要有如下要点
def:表示函数的关键字
函数名:函数的名称，日后根据函数名调用函数
函数体:函数中进行一系列的逻辑运算，比如，发送邮件，计算出[11,22,33,44]中的最大数等...
参数:为函数体提供数据
返回值:当函数执行完毕后，可以给调用者返回数据。
以上阐述介绍中，比较重要的有参数和返回值:
2.1.1返回值
函数式一个功能块，该功能到底执行是否成功，需要通过返回值来告知调用者。
def 发送短信():
发送短信的代码...
if 发送成功:
return True
else:
return Fales
while True:
#每次执行发送短信函数，都会将返回值自动赋值给result
#之后，可以根据result来写日志，或重发等操作
result = 发送短信()
if result == False:
记录日志，短信发送失败....
2.1.2函数的返回值 retun True
1.如果未明确指定返回值 则返回 None
2.如果返回值可以赋值给某个变量
2.1.3函数的参数
为什么要有参数？
无参数实现方式
def cpu报警邮件()
#发送邮件提醒
连接邮箱服务器
发送邮件
def 硬盘报警邮件()
#发送邮件提醒
连接邮箱服务器
发送邮件
while True:
if cpu利用率 > 90%:
cpu报警邮件 ()
if 硬盘使用空间 > 90%:
硬盘报警邮件()
有参数实现方式
def 发送邮件(邮件内容)
#发送邮件提醒
连接邮箱服务器
发送邮件
while True:
if cpu利用率 > 90%:
发送邮件("cpu报警了")
if 硬盘使用空间 > 90%:
发送邮件("硬盘报警了")
函数中有三种不同的参数
3.1普通参数
形式参数
实际参数
参数可以有n个，传人指定个数的参数
# ######### 定义函数 #########
# name 叫做函数func的形式参数，简称：形参
def func(name):
print name
# ######### 执行函数 #########
# ‘leyno‘ 叫做函数func的实际参数，简称：实参
func(‘leyno‘)
3.2默认参数
不传则使用默认值
必须放在参数列表的最后
可以指定所传参数
def func(name, age = 18):
print "%s:%s" %(name,age)
# 指定参数
func(‘leyno‘, 19)
# 使用默认参数
func(‘lili‘)
注：默认参数需要放在参数列表最后
3.3动态参数
单值可以多个
def func(*args): #*args（默认构造元祖）
print args[0] #可以指定返回几个参数，不指定就全都返回
# 执行方式一
#func(11,33,4,4454,5)
# 执行方式二
li = [‘1‘,‘2‘]
func(*li)
双值
def func(**kwargs): #**kwargs（默认构造字典）
print kwargs
# 执行方式一
func(K1=123,K2=‘SSS‘)
# 执行方式二
li = {‘name‘:‘leyno‘, ‘age‘:18, ‘gender‘:‘male‘}
func(**li)
两者结合体，自动分类
可以接受多个参数
内部自动构造元组
序列，*，避免内部构造元组
def func(*args, **kwargs):
print args
print kwargs
a = [11,22,33]
li = {‘name‘:‘wupeiqi‘,‘age‘:18, ‘gender‘:‘male‘}
func(*a,**li)
扩展：发送邮件实例
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
msg = MIMEText(‘邮件内容‘, ‘plain‘, ‘utf-8‘)
msg[‘From‘] = formataddr(["雷诺",‘[email protected]‘])
msg[‘To‘] = formataddr(["走人",‘[email protected]‘])
msg[‘Subject‘] = "主题"
server = smtplib.SMTP("smtp.126.com", 25)
server.login("[email protected]", "邮箱密码")
server.sendmail(‘[email protected]‘, [‘[email protected]‘,], msg.as_string())
server.quit()
文件操作详细
1.打开文件
obj = file(‘文件路径‘,‘打开方式‘)
obj = open(‘文件路径‘,‘打开方式‘)
打开文件方式: r只读，w写入，a追加
2.操作文件
obj.seek() #指定起始读写位置
obj.tell #输出指针位置
obj.read() #读取文件（只有r+能用，rU：\r转成\n）
obj.write() #写文件
obj.truncate() #截断，根据当前指针的位置（若接参数，就只保留参数个数的字节）
obj.fileno() #文件描述符
obj.flush() #刷新文件内部缓冲区到内存
obj.isatty() #判读文件是否是泳衣tty设备
obj.next() #读取下一行数据，不存在，则报错
obj.redinto() #读取文件到缓冲区，不建议使用，将被遗弃
obj.readline() #只读取一行数据，用于for循环读出
obj.readlines() #读取所有数据，并根据换行保存至列表
obj.writelines() #将一个字符串写入到文件
obj.xwritelines() #可用于逐写入文件，非全部
3.关闭文件
obj.close() #关闭文件，当打开一个文件就必须有关闭操作
with open(‘log‘,‘r‘) as obj: #(with可以同时打开多个文件)
obj.write() # (并且文件可以自动关闭不需要close动作)