python 函数初识和文件操作

 文件操作

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

 打开文件的模式

w                 　　  #以写的方式打开   （不可读，不存在则创建，存在则删除内容）
a                      #以追加的模式打开（可读，  不存在则创建，存在则追加内容）
r                      #以只读模式打开
"+"  表示可以同时读写某个文件
r+                     #以读写的模式打开
w+                     #以读写的模式打开        
a+                     #以读写的模式打开
 
"b”表示处理二进制文件
rb          　　　　　　 #以二进制模式读打开 
wb          　　　　　　 #以二进制写模式打开 
ab          　　　　　　 #以二进制追加模式打开    
 
rb+       　　　　　　 　 #以二进制读写模式打开
wb+       　　　　　　　　#以二进制读写模式打开
ab+      　　　　　　　　 #以二进制读写模式打开
 
"U" 表示在读取时，可以将
  
  
 自动转换成
 (与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脚本的功能，靠堆积一些命令来处理一些事情，按照业务的罗技从上到下的实现功能

 

1. whileTrue:
       if cpu利用率> 90%:
           #发送邮件提醒
           连接邮箱服务器
           发送邮件
           关闭连接
     
       if 硬盘使用空间> 90%:
           #发送邮件提醒
           连接邮箱服务器
           发送邮件
           关闭连接
     
       if 内存占用> 80%:
           #发送邮件提醒
           连接邮箱服务器
           发送邮件
           关闭连接
   

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

 
def 发送邮件(内容)
    #发送邮件提醒
    连接邮箱服务器
    发送邮件
    关闭连接
  
while True：
  
    if cpu利用率> 90%:
        发送邮件('CPU报警')
  
    if 硬盘使用空间> 90%:
        发送邮件('硬盘报警')
  
    if 内存占用> 80%:
      发送邮件("内存报警")

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

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

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

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

 

 函数的定义和使用 

1. def  foo(args):
       print "hello,world!"
       return args
   ret = foo(name) 
   print ret
   

   　　

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

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

 函数的参数 

 为什么要使用参数  ？

1. def 发送邮件(邮件内容)                  #邮件内容为参数
   #发送邮件提醒
   连接邮箱服务器
   发送邮件
   关闭连接
   whileTrue：
   if cpu利用率>90%:
   发送邮件("CPU报警了。")
   if硬盘使用空间>90%:
   发送邮件("硬盘报警了。")
   if内存占用>80%:
   发送邮件("内存报警了。")

 函数中参数的种类 

 1 , 普通参数 

 

1. def func(args):
       print args
   func("budonghsu")
   

   　　

 

 

 2 ，默认参数

1. def func(name,age =18):
       print "%s : %s"%(name,age)
   func("budongshu",19)
   func("budongshu")
    
   运行结果：
   budongshu :19
   budongshu :18
   

   　　

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

 

 

 3 ， 动态参数 

1. 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)
   

   　　

 

1. 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'}
    
   

   　　

1. 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)
    
   

   　　

1.  运行结果：

2. 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)

附件列表

• 1.jpg
• 2.jpg
• 2015-12-15_210352.png
• 3.png
• 4.png
• 4_2.png
• python发邮件.png