python 函数初识和文件操作

文件操作

打开文件：文件句柄 = open('文件路径', '模式')

打开文件的模式

w                 　　  #以写的方式打开   （不可读，不存在则创建，存在则删除内容）

a                      #以追加的模式打开（可读，  不存在则创建，存在则追加内容）

r                      #以只读模式打开

"+"  表示可以同时读写某个文件

r+                     #以读写的模式打开

w+                     #以读写的模式打开

a+                     #以读写的模式打开

"b”表示处理二进制文件

rb          　　　　　　 #以二进制模式读打开

wb          　　　　　　 #以二进制写模式打开

ab          　　　　　　 #以二进制追加模式打开    

rb+       　　　　　　 　 #以二进制读写模式打开

wb+       　　　　　　　　#以二进制读写模式打开

ab+      　　　　　　　　 #以二进制读写模式打开

"U" 表示在读取时，可以将\r  \n  \r\n 自动转换成\n (与r或者r+模式相同)

rU

r+U3

fp = open("test.txt",w)

fp.close         　　    #关闭文件， 养成习惯，打开文件，用完后，记得关闭，否则有可能报ValueError

fp.fileno          　 　 #返回一个文件描述符，使用底层的操作请求系统 I/O操作

fp.flush           　　  #刷新文件内容缓冲区

fp.isatty           　　 #文件是否是一个终端设备文件（unix系统中的)

fp.next              　　#获取下一行的数据，不 存在则报错 。 for i in file: print i.strip() 就是调用这个next()方法

fp.read([size])                    #读取指定字节数的数据 以byte 为单位

fp.readline([size])                #读一行，如果定义了size ，有可能返回一行中的部分

fp.readlines([size])               #把文件每一行作为一个list的一个成员，并返回这个list。内部还是调用readline()方法

fp.seek(offset[,whence])           #将文件操作移动到offset的位置，这个offset一般相对文件的开头开计算的，一般为整数，

                                         #0 从头开始计算

                                         #1 从当前位置开始计算

                                         #2 从未见末尾开始计算

fp.tell                            #告诉文件操作的当前位置 ，从开头开始计算

fp.truncate                        #把文件裁成规定的大小，默认是裁到当前文件操作标记的位置

fp.write                           #往文件里面写内容

fp.writelines                      #将一个字符串列表写入文件

fp.closed                          #关闭文件

fp.encoding                     　

fp.errors　　　　　　　　　　　　　 　　

fp.mode　　　　　　　　　　　　　　

fp.name　　　　　　　 　　　　　　   
fp.newlines　　　　　　　　　　　　  
fp.softspace

with 应用

1，为了避免打开文件后，忘记关闭，可以通过管理上下文：

with open("log.txt","r") as f:                #只读的方式打开文件，alias 为f

    for line in f:

        print line                            #打印每一行

                                              #执行完成后内部会自动关闭并释放文件资源

2，在python2.7后，with又支持同时对多个文件的上下文进行管理

with open("log1.txt") as obj1  , open("log2.txt")  as obj2:    #可以进行复制的操作

    for line in obj1:

        obj2.write(line)

python每行读取文件几种姿势

#1 ,readline

file = open("a.log","r")　　

whileTrue:

        line = file.readline()

        if not line:

                break

        pass

#2 ,fileinput

import fileinput

file = open("a.log","r")

for line in fileinput.input("a.log"):

        pass

#3 ,readlines

file = open("a.log","r")

whileTrue:

        lines = file.readlines(100000)

        if not lines:

                break

        for line in lines:

                pass

#4 ,for循环

file = open("a.log","r")                         # 相当于with  open("a.log","r")  as f:

                                                 #                  for  line in  f:

for line in file:                                #                           pass

        pass

#5 ,xreadlines

file = open("a.log","r")                         #已经废弃

for line in file.xreadlines():

        pass

自定义函数

在学习函数之前，一直都是遵循面向过程编程，类似于shell脚本的功能，靠堆积一些命令来处理一些事情，按照业务的罗技从上到下的实现功能

whileTrue:

    if cpu利用率> 90%:

        #发送邮件提醒

        连接邮箱服务器

        发送邮件

        关闭连接

    if 硬盘使用空间> 90%:

        #发送邮件提醒

        连接邮箱服务器

        发送邮件

        关闭连接

    if 内存占用> 80%:

        #发送邮件提醒

        连接邮箱服务器

        发送邮件

        关闭连接

看一下上面的代码，可以将if 语句内容提取出来公用，如下:

def 发送邮件(内容)

    #发送邮件提醒

    连接邮箱服务器

    发送邮件

    关闭连接

while True：

    if cpu利用率> 90%:

        发送邮件('CPU报警')

    if 硬盘使用空间> 90%:

        发送邮件('硬盘报警')

    if 内存占用> 80%:

      发送邮件("内存报警")

对于上述俩种实现的方式，第二次显示比第一次的重用性和可读性要好，其实这也是函数式编程和面向过程编程的区别

函数式：将某功能代码封装到函数中，日后便无需重复编写，仅需要调用函数即可

面向对象：对函数进行分类和封装，让开发"更快，更强。。。"

函数式编程最重要的是增强代码的重用性和可读性

函数的定义和使用

def  foo(args):

    print "hello,world!"

    return args

ret = foo(name)

print ret

注意：上面是调用一个函数，写错了

foo(name) 改为 foo("name")

函数的参数

为什么要使用参数？

def 发送邮件(邮件内容)                  #邮件内容为参数

#发送邮件提醒

连接邮箱服务器

发送邮件

关闭连接

whileTrue：

if cpu利用率>90%:

发送邮件("CPU报警了。")

if硬盘使用空间>90%:

发送邮件("硬盘报警了。")

if内存占用>80%:

发送邮件("内存报警了。")

函数中参数的种类

1 , 普通参数

def func(args):

    print args

func("budonghsu")

2 ，默认参数

def func(name,age =18):

    print "%s : %s"%(name,age)

func("budongshu",19)

func("budongshu")

运行结果：

budongshu :19

budongshu :18

注意：默认参数要放在参数列表的最后面

3 ，动态参数

def func(*arg):              #可以接收列表，元组 ，字符串

    print arg

执行方式一

name =[1,2,3,4]

func(name)

name =("a","b")

func(name)

执行方式二

func("bds",123) 

执行结果：                           #返回的是一个元组

([1, 2, 3, 4],) (('a', 'b'),) ('bds', 123)

def func(**kwargs):                 #可以接收字典

   print kwargs

func(name="bds",age=19) 　　         #此方法还可以用来生成字典

dict1 ={'name':"linux",'age':20}

func(**dict1)

运行结果:

{'age':19,'name':'bds'}

{'age':20,'name':'linux'}

def foo(*arg,**kwargs):

        print 'arg = ', arg

        print 'kwargs =', kwargs

        print '-------------------------'

foo(1,2,3,4)

foo(a=1,b=2,c=3)

foo(1,2,3,4,a=1,b=2,c=3)

foo('a',1,None,a=1,b='2',c=3)

运行结果：

arg =  (1,2,3,4)

kwargs ={}

-------------------------

arg =  ()

kwargs ={'a':1,'c':3,'b':2}

-------------------------

arg =  (1,2,3,4)

kwargs ={'a':1,'c':3,'b':2}

-------------------------

arg =  ('a',1,None)

kwargs ={'a':1,'c':3,'b':'2'}

-------------------------

python发邮件

#!/usr/bin/env python

#conding:utf-8 *_*

import smtplib

from email.mime.text import MIMEText

from email.utils import formataddr

msg = MIMEText('my name is budongshu', 'plain', 'utf-8')

msg['From'] = formataddr(["budongshu",'bdstravel@126.com'])

msg['To'] = formataddr(["qq",'2329435445@qq.com'])

msg['Subject'] = "hello hero subnet"

server = smtplib.SMTP("smtp.126.com", 25)

server.login("bdstravel@126.com", "你的密码")

server.sendmail('bdstravel@126.com', ['2329435445@qq.com',], msg.as_string())

server.quit()

详解如图：

测试：

来自为知笔记(Wiz)

附件列表