首页 > 代码库 > Day 18(06/13) 文件处理、函数

Day 18(06/13) 文件处理、函数

  • 一.文件处理流程
  • 二.基本操作
  • 2.1 文件操作基本流程初探
  • 2.2 文件编码
  • 2.3 文件打开模式
  • 2.4 文件内置函数flush
  • 2.5 文件内光标移动
  • 2.6 open函数详解
  • 2.7 上下文管理
  • 2.8 文件的修改

一.文件处理流程

  1. 打开文件,得到文件句柄并赋值给一个变量
  2. 通过句柄对文件进行操作
  3. 关闭文件

二.基本操作

2.1 文件操作基本流程初探

f = open(‘chenli.txt‘) #打开文件
first_line = f.readline()
print(‘first line:‘,first_line) #读一行
print(‘我是分隔线‘.center(50,‘-‘))
data = http://www.mamicode.com/f.read()# 读取剩下的所有内容,文件大时不要用>


2.2 文件编码

文件保存编码如下

技术分享

此刻错误的打开方式
f=open(‘chenli.txt‘,encoding=‘utf-8‘)
f.read() 

技术分享

正确的打开方式
#不指定打开编码,默认使用操作系统的编码,windows为gbk,linux为utf-8,与解释器编码无关
f=open(‘chenli.txt‘,encoding=‘gbk‘) #在windows中默认使用的也是gbk编码,此时不指定编码也行
f.read()
 

2.3 文件打开模式

1 文件句柄 = open(‘文件路径‘, ‘模式‘)

 

打开文件时,需要指定文件路径和以何等方式打开文件,打开后,即可获取该文件句柄,日后通过此文件句柄对该文件操作。

打开文件的模式有:

  • r ,只读模式【默认模式,文件必须存在,不存在则抛出异常】
  • w,只写模式【不可读;不存在则创建;存在则清空内容】
  • x, 只写模式【不可读;不存在则创建,存在则报错】
  • a, 追加模式【可读;   不存在则创建;存在则只追加内容】

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

  • r+, 读写【可读,可写】
  • w+,写读【可读,可写】
  • x+ ,写读【可读,可写】
  • a+, 写读【可读,可写】

 "b"表示以字节的方式操作

  • rb  或 r+b
  • wb 或 w+b
  • xb 或 w+b
  • ab 或 a+b

 注:以b方式打开时,读取到的内容是字节类型,写入时也需要提供字节类型,不能指定编码



2.4 文件内置函数flush

flush原理:

  1. 文件操作是通过软件将文件从硬盘读到内存
  2. 写入文件的操作也都是存入内存缓冲区buffer(内存速度快于硬盘,如果写入文件的数据都从内存刷到硬盘,内存与硬盘的速度延迟会被无限放大,效率变低,所以要刷到硬盘的数据我们统一往内存的一小块空间即buffer中放,一段时间后操作系统会将buffer中数据一次性刷到硬盘)
  3. flush即,强制将写入的数据刷到硬盘

滚动条:

import sys,time

for i in  range(10):
    sys.stdout.write(‘#‘)
    sys.stdout.flush()
    time.sleep(0.2)

 

2.5 文件内光标移动

注意:read(3)代表读取3个字符,其余的文件内光标移动都是以字节为单位如seek,tell,read,truncate

 

2.6 open函数详解

1. open()语法

open(file[, mode[, buffering[, encoding[, errors[, newline[, closefd=True]]]]]])
open函数有很多的参数,常用的是file,mode和encoding
file文件位置,需要加引号
mode文件打开模式,见下面3
buffering的可取值有0,1,>1三个,0代表buffer关闭(只适用于二进制模式),1代表line buffer(只适用于文本模式),>1表示初始化的buffer大小;
encoding表示的是返回的数据采用何种编码,一般采用utf8或者gbk;
errors的取值一般有strict,ignore,当取strict的时候,字符编码出现问题的时候,会报错,当取ignore的时候,编码出现问题,程序会忽略而过,继续执行下面的程序。
newline可以取的值有None, \n, \r, ”, ‘\r\n‘,用于区分换行符,但是这个参数只对文本模式有效;
closefd的取值,是与传入的文件参数有关,默认情况下为True,传入的file参数为文件的文件名,取值为False的时候,file只能是文件描述符,什么是文件描述符,就是一个非负整数,在Unix内核的系统中,打开一个文件,便会返回一个文件描述符。

2. Python中file()与open()区别
两者都能够打开文件,对文件进行操作,也具有相似的用法和参数,但是,这两种文件打开方式有本质的区别,file为文件类,用file()来打开文件,相当于这是在构造文件类,而用open()打开文件,是用python的内建函数来操作,建议使用open

3. 参数mode的基本取值

Character Meaning
‘r‘ open for reading (default)
‘w‘ open for writing, truncating the file first
‘a‘ open for writing, appending to the end of the file if it exists
‘b‘ binary mode
‘t‘ text mode (default)
‘+‘ open a disk file for updating (reading and writing)
‘U‘ universal newline mode (for backwards compatibility; should not be used in new code)

r、w、a为打开文件的基本模式,对应着只读、只写、追加模式;
b、t、+、U这四个字符,与以上的文件打开模式组合使用,二进制模式,文本模式,读写模式、通用换行符,根据实际情况组合使用、

常见的mode取值组合

r或rt 默认模式,文本模式读
rb 二进制文件

w或wt 文本模式写,打开前文件存储被清空
wb 二进制写,文件存储同样被清空

a 追加模式,只能写在文件末尾
a+ 可读写模式,写只能写在文件末尾

w+ 可读写,与a+的区别是要清空文件内容
r+ 可读写,与a+的区别是可以写到文件任何位置

 

2.7 上下文管理

with open(‘a.txt‘,‘w‘) as f:
    pass

 

with open(‘a.txt‘,‘r‘) as read_f,open(‘b.txt‘,‘w‘) as write_f:
    data=http://www.mamicode.com/read_f.read()>

 

2.8 文件的修改

import os
with open(‘a.txt‘,‘r‘,encoding=‘utf-8‘) as read_f,\
open(‘.a.txt.swap‘,‘w‘,encoding=‘utf-8‘) as write_f:
for line in read_f:
if line.startswith(‘hello‘):
line=‘哈哈哈\n‘
write_f.write(line)

os.remove(‘a.txt‘)
os.rename(‘.a.txt.swap‘,‘a.txt‘)

PS:http://www.cnblogs.com/linhaifeng/articles/5984922.html (详见参考老师博客)

 

 

  • 一 数学定义的函数与python中的函数
  • 二 为何使用函数
  • 背景提要
  • 三 函数和过程
  • 四 函数参数
  • 五 局部变量和全局变量
  • 六 前向引用之‘函数即变量‘
  • 七 嵌套函数和作用域
  • 八 递归调用
  • 九 匿名函数
  • 十 函数式编程
  • 十一 内置函数
  • 十二 本节作业
 

一 数学定义的函数与python中的函数

初中数学函数定义:一般的,在一个变化过程中,如果有两个变量x和y,并且对于x的每一个确定的值,y都有唯一确定的值与其对应,那么我们就把x称为自变量,把y称为因变量,y是x的函数。自变量x的取值范围叫做这个函数的定义域

例如y=2*x

 

python中函数定义:函数是逻辑结构化和过程化的一种编程方法。

 
 1 python中函数定义方法:
 2  
 3 def test(x):
 4     "The function definitions"
 5     x+=1
 6     return x
 7      
 8 def:定义函数的关键字
 9 test:函数名
10 ():内可定义形参
11 "":文档描述(非必要,但是强烈建议为你的函数添加描述信息)
12 x+=1:泛指代码块或程序处理逻辑
13 return:定义返回值


调用运行:可以带参数也可以不带
函数名()
 

补充:

1.编程语言中的函数与数学意义的函数是截然不同的俩个概念,编程语言中的函数是通过一个函数名封装好一串用来完成某一特定功能的逻辑,数学定义的函数就是一个等式,等式在传入因变量值x不同会得到一个结果y,这一点与编程语言中类似(也是传入一个参数,得到一个返回值),不同的是数学意义的函数,传入值相同,得到的结果必然相同且没有任何变量的修改(不修改状态),而编程语言中的函数传入的参数相同返回值可不一定相同且可以修改其他的全局变量值(因为一个函数a的执行可能依赖于另外一个函数b的结果,b可能得到不同结果,那即便是你给a传入相同的参数,那么a得到的结果也肯定不同)

2.函数式编程就是:先定义一个数学函数(数学建模),然后按照这个数学模型用编程语言去实现它。至于具体如何实现和这么做的好处,且看后续的函数式编程。



二 为何使用函数

 

背景提要

现在老板让你写一个监控程序,监控服务器的系统状况,当cpu\memory\disk等指标的使用量超过阀值时即发邮件报警,你掏空了所有的知识量,写出了以下代码

 
 1 while True:
 2     if cpu利用率 > 90%:
 3         #发送邮件提醒
 4         连接邮箱服务器
 5         发送邮件
 6         关闭连接
 7      
 8     if 硬盘使用空间 > 90%:
 9         #发送邮件提醒
10         连接邮箱服务器
11         发送邮件
12         关闭连接
13      
14     if 内存占用 > 80%:
15         #发送邮件提醒
16         连接邮箱服务器
17         发送邮件
18         关闭连接
 

上面的代码实现了功能,但即使是邻居老王也看出了端倪,老王亲切的摸了下你家儿子的脸蛋,说,你这个重复代码太多了,每次报警都要重写一段发邮件的代码,太low了,这样干存在2个问题:

  1. 代码重复过多,一个劲的copy and paste不符合高端程序员的气质
  2. 如果日后需要修改发邮件的这段代码,比如加入群发功能,那你就需要在所有用到这段代码的地方都修改一遍

你觉得老王说的对,你也不想写重复代码,但又不知道怎么搞,老王好像看出了你的心思,此时他抱起你儿子,笑着说,其实很简单,只需要把重复的代码提取出来,放在一个公共的地方,起个名字,以后谁想用这段代码,就通过这个名字调用就行了,如下

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

你看着老王写的代码,气势恢宏、磅礴大气,代码里透露着一股内敛的傲气,心想,老王这个人真是不一般,突然对他的背景更感兴趣了,问老王,这些花式玩法你都是怎么知道的? 老王亲了一口你儿子,捋了捋不存在的胡子,淡淡的讲,“老夫,年少时,师从京西沙河淫魔银角大王 ”, 你一听“银角大王”这几个字,不由的娇躯一震,心想,真nb,怪不得代码写的这么6, 这“银角大王”当年在江湖上可是数得着的响当当的名字,只可惜后期纵欲过度,卒于公元2016年, 真是可惜了,只留下其哥哥孤守当年兄弟俩一起打下来的江山。 此时你看着的老王离开的身影,感觉你儿子跟他越来越像了。。。

总结使用函数的好处:

1.代码重用

2.保持一致性,易维护

3.可扩展性

 

三 函数和过程

过程定义:过程就是简单特殊没有返回值的函数

这么看来我们在讨论为何使用函数的的时候引入的函数,都没有返回值,没有返回值就是过程,没错,但是在python中有比较神奇的事情

 
 1 def test01():
 2     msg=‘hello The little green frog‘
 3     print msg
 4  
 5 def test02():
 6     msg=‘hello WuDaLang‘
 7     print msg
 8     return msg
 9  
10  
11 t1=test01()
12  
13 t2=test02()
14  
15  
16 print ‘from test01 return is [%s]‘ %t1
17 print ‘from test02 return is [%s]‘ %t2
 

总结:当一个函数/过程没有使用return显示的定义返回值时,python解释器会隐式的返回None,

所以在python中即便是过程也可以算作函数。

 
 1 def test01():
 2     pass
 3  
 4 def test02():
 5     return 0
 6  
 7 def test03():
 8     return 0,10,‘hello‘,[‘alex‘,‘lb‘],{‘WuDaLang‘:‘lb‘}
 9  
10 t1=test01()
11 t2=test02()
12 t3=test03()
13  
14  
15 print ‘from test01 return is [%s]: ‘ %type(t1),t1
16 print ‘from test02 return is [%s]: ‘ %type(t2),t2
17 print ‘from test03 return is [%s]: ‘ %type(t3),t3
 

总结:

   返回值数=0:返回None

   返回值数=1:返回object

   返回值数>1:返回tuple

 

四 函数参数

1.形参变量只有在被调用时才分配内存单元,在调用结束时,即刻释放所分配的内存单元。因此,形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量

2.实参可以是常量、变量、表达式、函数等,无论实参是何种类型的量,在进行函数调用时,它们都必须有确定的值,以便把这些值传送给形参。因此应预先用赋值,输入等办法使参数获得确定值

技术分享

 

3.位置参数和关键字(标准调用:实参与形参位置一一对应;关键字调用:位置无需固定)

4.默认参数

5.参数组

 

五 局部变量和全局变量

在子程序中定义的变量称为局部变量,在程序的一开始定义的变量称为全局变量。
全局变量作用域是整个程序,局部变量作用域是定义该变量的子程序。
当全局变量与局部变量同名时:
在定义局部变量的子程序内,局部变量起作用;在其它地方全局变量起作用。
 
 1 name=‘lhf‘
 2 
 3 def change_name():
 4     print(‘我的名字‘,name)
 5 
 6 change_name()
 7 
 8 
 9 def change_name():
10     name=‘帅了一笔‘
11     print(‘我的名字‘,name)
12 
13 change_name()
14 print(name)
15 
16 
17 
18 def change_name():
19     global name
20     name=‘帅了一笔‘
21     print(‘我的名字‘,name)
22 
23 change_name()
24 print(name)
 
 

六 前向引用之‘函数即变量‘

 
 1 def action():
 2     print ‘in the action‘
 3     logger()
 4 action()
 5 报错NameError: global name ‘logger‘ is not defined
 6 
 7 
 8 def logger():
 9     print ‘in the logger‘
10 def action():
11     print ‘in the action‘
12     logger()
13  
14 action()
15  
16 
17 def action():
18     print ‘in the action‘
19     logger()
20 def logger():
21     print ‘in the logger‘
22  
23 action() 
 
 

七 嵌套函数和作用域

看上面的标题的意思是,函数还能套函数?of course

 
 1 name = "Alex"
 2  
 3 def change_name():
 4     name = "Alex2"
 5  
 6     def change_name2():
 7         name = "Alex3"
 8         print("第3层打印",name)
 9  
10     change_name2() #调用内层函数
11     print("第2层打印",name)
12  
13  
14 change_name()
15 print("最外层打印",name)
 

此时,在最外层调用change_name2()会出现什么效果?

没错, 出错了, 为什么呢?

 

作用域在定义函数时就已经固定住了,不会随着调用位置的改变而改变

 
 1 例一:
 2 name=‘alex‘
 3 
 4 def foo():
 5     name=‘lhf‘
 6     def bar():
 7         print(name)
 8     return bar
 9 
10 func=foo()
11 func()
12 
13 
14 例二:
15 name=‘alex‘
16 
17 def foo():
18     name=‘lhf‘
19     def bar():
20         name=‘wupeiqi‘
21         def tt():
22             print(name)
23         return tt
24     return bar
25 
26 func=foo()
27 func()()
 

 

ps:http://www.cnblogs.com/linhaifeng/articles/6113086.html 

Day 18(06/13) 文件处理、函数