python 进入上一层文件夹 python进入d盘某个文件夹

转载

mob6454cc7901c3 2024-07-29 16:12:48

文章标签 python 进入上一层文件夹发送邮件打开文件 python 文章分类 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

python 进入上一层文件夹 python进入d盘某个文件夹_打开文件

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

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

函数的参数

为什么要使用参数？

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

函数中参数的种类

1 , 普通参数

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

python 进入上一层文件夹 python进入d盘某个文件夹_打开文件_02

2 ，默认参数

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

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

python 进入上一层文件夹 python进入d盘某个文件夹_python_03

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