Day3 文件操作和函数

一 文件操作

• 打开文件，得到文件句柄并赋值给一个变量
• 通过句柄对文件进行操作
• 关闭文件

1.1打开文件读取内容

print(open("sounds","r",encoding="utf-8").read())
Somehow, it seems the love I knew was always the most destructive kind
 
Yesterday when I was young
 
The taste of life was sweet
 
As rain upon my tongue
 
I teased at life asif it were a foolish game

1.2文件内存对象

正常对于一个文件打开，在进行操作，是需要加载到内容中，并在内存对象里赋值一个变量，后续再找到这个变量，来操作文件，这个文件对象就是文件句柄，一般情况通常都是用f来指定

f =(open("sounds","r",encoding="utf-8"))
print(f.read())
 
Somehow, it seems the love I knew was always the most destructive kind
 
Yesterday when I was young
 
The taste of life was sweet
 
As rain upon my tongue
 
I teased at life asif it were a foolish game

1.3在文件里写入内容

使用下面的方式会对源文件覆盖，w会写入覆盖，而且是不可读的，具体后面有讲解

f =(open("sounds","w",encoding="utf-8"))
f.write("chuck is most handsome\n")#\n为回车换行符
 
f.write("楼上说的对")
 
f.close()

1.4在文件中追加

f =(open("sounds","a",encoding="utf-8"))
f.write("chuck is most handsome\n")#\n为回车换行符
 
f.write("楼上说的对")
 
f.close()
 
##文件内容如下，可以看到追加了两行
 
Somehow, it seems the love I knew was always the most destructive kind
 
Yesterday when I was young
 
The taste of life was sweet
 
As rain upon my tongue
 
I teased at life asif it were a foolish game
 
chuck is most handsome
 
楼上说的对

1.5使用readline只打印前五行内容

使用readline按行读取文件内容，使用for循环读出文件的前五行

f =(open("sounds","r",encoding="utf-8"))
for line in range(5):
 
print(f.readline().strip())
 
f.close()
 
Somehow, it seems the love I knew was always the most destructive kind
 
Yesterday when I was young
 
The taste of life was sweet
 
As rain upon my tongue
 
I teased at life asif it were a foolish game

1.6使用readlines不输出将第五行变为其他输出

readlines的输出其实是将每一行当做一个元素转换成一个列表，使用for循环将其输出其实就是在循环列表内容

f =(open("sounds","r",encoding="utf-8"))
count =1
 
for line in f.readlines():
 
if count ==5:
 
print("看到没，这是第%s行"% count)
 
print(line.strip())
 
count +=1
 
Somehow, it seems the love I knew was always the most destructive kind
 
Yesterday when I was young
 
The taste of life was sweet
 
As rain upon my tongue
 
看到没，这是第5行
 
I teased at life asif it were a foolish game

1.7直接循环f，逐行加载到内存中，读一行删掉一行

使用readlines的方法是逐行读取内容完一次性加载到内存中，如果文件过大，就会影响内存的使用率，加大了内存的使用空间，从磁盘读取到内存会浪费很多时间，readlines只适合读小文件，所以这时要引入其他方法来读取大文件，使用循环f方法，逐行加载到内存中，读一行删掉一行,使用此方法后内容不再是一个列表，是一个迭代器似的内容，建议以后使用此方法循环读取文件内容

f =(open("sounds","r",encoding="utf-8"))
count =1
 
for line in f:
 
if count ==5:
 
print("看到没，这是第%s行"% count)
 
print(line.strip())
 
count +=1
 
f.close()
 
Somehow, it seems the love I knew was always the most destructive kind
 
Yesterday when I was young
 
The taste of life was sweet
 
As rain upon my tongue
 
看到没，这是第5行
 
I teased at life asif it were a foolish game

1.8 移动读取写入文件的光标

• 文件初始位置光标为0

f =(open("sounds","r",encoding="utf-8"))
print(f.tell())
 
0

• 读入一行后输出

f =(open("sounds","r",encoding="utf-8"))
f.readline()
 
print(f.tell())
 
72

• 使用read读取指定的字符数

f =(open("sounds","r",encoding="utf-8"))
f.readline()
 
print(f.read(20))
 
print(f.tell())
 
Yesterday when I was
 
92

• 使用seek回到默认位置,seek和tell往往搭配起来使用

f =(open("sounds","r",encoding="utf-8"))
f.readline()
 
print(f.read(20))
 
f.seek(0)
 
print(f.tell())
 
Yesterday when I was
 
0

1.8 其他一些操作文件的方法

• 使用encoding打印文件的编码

f =(open("sounds","r",encoding="utf-8"))
print(f.encoding)
 
utf-8

• errors用来做异常处理的
• fileno返回操作系统的接口的id，无需关注
• name打印文件名字
• tty判断是否为一个终端设备
• seekable判断是否可以移动光标
• readable判断文件是否可读，防止报错
• writeable判断文件是否可写，防止报错
• buffer内存里的一个临时文件
• flush将内存的内容刷到磁盘中

有些情况写文件，会首先写到buffer中，然后达到一定大小刷新到磁盘，这是缓冲的一个优势，如果对数据要求实时的一致性，要求对数据很严格，这时使用flush可以实现写每行内容立马刷进磁盘中，还可以使用flush打印进度条

import sys,time
for i in range(30):
 
sys.stdout.write(">>")
 
sys.stdout.flush()
 
time.sleep(0.1)

• truncate截断文件内的光标,无论是光标在哪，都会从开头计算截断位置

f =(open("sounds","a",encoding="utf-8"))
f.truncate(55)

1.9 对文件的权限读写权限介绍

** 打开文件的模式有：**

• r，只读模式（默认）。
• w，只写模式。【不可读；不存在则创建；存在则删除内容；】
• a，追加模式。【可读；不存在则创建；存在则只追加内容；】

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

• r+，可读写文件。【可读；可写；可追加】实际是从最后追加内容，比较常用
• w+，写读，和r+区别是先创建一个新文件后写入，python3.0不能使用seek移动光标后写入，一定都是从最后一行写入,实际上写读模式没什么卵用
• a+，同a

“U”表示在读取时，可以将 \r \n \r\n自动转换成 \n （与 r 或 r+ 模式同使用）

• rU
• r+U

“b”表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注，python3.0中socket传输只能使用二进制内容，二进制内容最好都是用二进制方式打开，否则可能会损坏文件）

• rb
• wb
• ab

1.10 修改文件里的指定内容

上面说了对文件的写读等操作，如果想要修改文件的指定内容，就需要将文件加载到内存中，在内存里修改，修改后在写回源文件，就不需要创建新文件了，但是文件太大就不合适了，内存会跑满；另一种方式是打开一个文件修改，最后写入到一个新文件里,这种方式可以应对大文件的更改，下面就是用第二种方式实现更改

原文件内容如下：

Somehow, it seems the love I knew was always the most destructive kind
Yesterday when I was young
 
The taste of life was sweet
 
As rain upon my tongue
 
I teased at life asif it were a foolish game
 
The way the evening breeze

将第5行的tongue改为eyes

f = open("sounds","r",encoding="utf-8")
f2 = open("sounds2","w",encoding="utf-8")
 
for line in f:
 
if"tongue"in line:
 
line = line.replace("tongue","eyes")
 
f2.write(line)
 
f.close()
 
f2.close()

新文件如下

Somehow, it seems the love I knew was always the most destructive kind
Yesterday when I was young
 
The taste of life was sweet
 
As rain upon my eyes
 
I teased at life asif it were a foolish game
 
The way the evening breeze

1.11 学习操作文件的with方法

使用直接使用open打开文件是需要关闭的，最好是手动close，但是程序执行完依旧是会关闭文件，如果不进行手动关闭，打开文件过多的时候，只要程序不退出，打开的文件句柄始终不退出，直到程序结束时才会关闭，造成了内存空间关闭，所以要实时关闭，引入with方法，with支持同时打开多个文件，建议多使用with语法

with语句

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

with open('log','r')as f:
...

如此方式，当with代码块执行完毕时，内部会自动关闭并释放文件资源。

在Python 2.7 后，with又支持同时对多个文件的上下文进行管理，即：

with open('log1')as obj1, open('log2')as obj2:pass

使用范例：

with open("sounds","r",encoding="utf-8")as f:
for line in f:
 
print(line.strip())
 
Somehow, it seems the love I knew was always the most destructive kind
 
Yesterday when I was young
 
The taste of life was sweet
 
As rain upon my tongue
 
I teased at life asif it were a foolish game
 
The way the evening breeze

二 函数

2.1 函数定义

函数一词来源于数学，但编程中的「函数」概念，与数学中的函数是有很大不同的，具体区别，我们后面会讲，编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做subroutine(子过程或子程序)，在Pascal中叫做procedure(过程)和function，在C中只有function，在Java里面叫做method。

定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可

特性:

1. 减少重复代码
2. 使程序变的可扩展
3. 使程序变得易维护

语法定义

def sayhi():#函数名
 
    print("Hello, I'm nobody!")
 
sayhi() #调用函数

可以带参数

#下面这段代码
a,b = 5,8
 
c = a**b
 
print(c)

#改成用函数写

def calc(x,y):
    res = x**y
 
    return res #返回函数执行结果
 
c = calc(a,b) ＃结果赋值给c变量
 
print(c)

2.2 函数参数与局部变量

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

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

2.2.1 默认参数

def stu_register(name,age,country,course):
    print("----注册学生信息------")
 
    print("姓名:",name)
 
    print("age:",age)
 
    print("国籍:",country)
 
    print("课程:",course)
 
stu_register("王山炮",22,"CN","python_devops")
 
stu_register("张叫春",21,"CN","linux")
 
stu_register("刘老根",25,"CN","linux")

发现 country 这个参数 基本都 是"CN", 就像我们在网站上注册用户，像国籍这种信息，你不填写，默认就会是 中国， 这就是通过默认参数实现的，把country变成默认参数非常简单

def stu_register(name,age,course,country="CN"):

这样，这个参数在调用时不指定，那默认就是CN，指定了的话，就用你指定的值。

另外，你可能注意到了，在把country变成默认参数后，我同时把它的位置移到了最后面，默认参数必须在位置参数后面。

2.2.2 关键参数

正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可，但记住一个要求就是，关键参数必须放在位置参数之后。

stu_register(age=22,name='alex',course="python",)

2.2.3 非固定参数

若你的函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数====传元组

def stu_register(name,age,*args): # *args 会把多传入的参数变成一个元组形式
    print(name,age,args)
 
stu_register("Alex",22)
 
#输出
 
#Alex 22 () #后面这个()就是args,只是因为没传值,所以为空
 
stu_register("Jack",32,"CN","Python")
 
#输出
 
# Jack 32 ('CN', 'Python')

还可以有一个**kwargs======传字典

def stu_register(name,age,*args,**kwargs): # *kwargs 会把多传入的参数变成一个dict形式
print(name,age,args,kwargs)
 
stu_register("Alex",22)
 
#输出
 
#Alex 22 () {}#后面这个{}就是kwargs,只是因为没传值,所以为空
 
stu_register("Jack",32,"CN","Python",sex="Male",province="ShanDong")
 
#输出
 
# Jack 32 ('CN', 'Python') {'province': 'ShanDong', 'sex': 'Male'}

2.2.4 局部变量

name = "Alex Li"
def change_name(name):
 
    print("before change:",name)
 
    name = "金角大王,一个有Tesla的男人"
 
    print("after change", name)
 
change_name(name)
 
print("在外面看看name改了么?",name)

#输出：

before change: Alex Li
after change 金角大王,一个有Tesla的男人
 
在外面看看name改了么? Alex Li

2.2.5 全局变量和局部变量

在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。

全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。

当全局变量与局部变量同名时：

在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

2.3 函数的返回值

要想获取函数的执行结果，就可以用return语句把结果返回

注意:

1. 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束
2. 如果未在函数中指定return,那这个函数的返回值为None

2.4 嵌套函数

name = "Alex"
 
def change_name():
    name = "Alex2"
 
    def change_name2():
 
        name = "Alex3"
 
        print("第3层打印",name)
 
    change_name2() #调用内层函数
 
    print("第2层打印",name)
 
change_name()
 
print("最外层打印",name)

2.5 函数式编程

函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。

函数式编程中的函数这个术语不是指计算机中的函数（实际上是Subroutine），而是指数学中的函数，即自变量的映射。也就是说一个函数的值仅决定于函数参数的值，不依赖其他状态。比如sqrt(x)函数计算x的平方根，只要x不变，不论什么时候调用，调用几次，值都是不变的。

Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。

一、定义

简单说，"函数式编程"是一种"编程范式"（programming paradigm），也就是如何编写程序的方法论。

主要思想是把运算过程尽量写成一系列嵌套的函数调用。举例来说，现在有这样一个数学表达式：

　(1 + 2) * 3 - 4

传统的过程式编程，可能这样写：

　　var a = 1 + 2;

var b = a * 3;

var c = b - 4;

函数式编程要求使用函数，我们可以把运算过程定义为不同的函数，然后写成下面这样：

　　var result = subtract(multiply(add(1,2), 3), 4);

这段代码再演进以下，可以变成这样

add(1,2).multiply(3).subtract(4)

这基本就是自然语言的表达了。再看下面的代码，大家应该一眼就能明白它的意思吧：

merge([1,2],[3,4]).sort().search("2")

因此，函数式编程的代码更容易理解。

2.6 高阶函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

def add(x,y,f):
    return f(x) + f(y)
 
    res = add(3,-6,abs)
 
    print(res)