python基础（三）-- 文件操作

一． 文件操作:

对文件操作流程

1、打开文件，得到文件句柄并赋值给一个变量

2、通过句柄对文件进行操作

3、关闭文件

现有文件如下 ：

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 as if it were a foolish game

我戏弄生命 视其为愚蠢的游戏

The way the evening breeze

就如夜晚的微风

May tease the candle flame

逗弄蜡烛的火苗

The thousand dreams I dreamed

我曾千万次梦见

The splendid things I planned

那些我计划的绚丽蓝图

I always built to last on weak and shifting sand

但我总是将之建筑在易逝的流沙上

I lived by night and shunned the naked light of day

我夜夜笙歌 逃避白昼赤裸的阳光

And only now I see how the time ran away

事到如今我才看清岁月是如何匆匆流逝

Yesterday when I was young

昨日当我年少轻狂

So many lovely songs were waiting to be sung

有那么多甜美的曲儿等我歌唱

So many wild pleasures lay in store for me

有那么多肆意的快乐等我享受

And so much pain my eyes refused to see

还有那么多痛苦 我的双眼却视而不见

I ran so fast that time and youth at last ran out

我飞快地奔走 最终时光与青春消逝殆尽

I never stopped to think what life was all about

我从未停下脚步去思考生命的意义

And every conversation that I can now recall

如今回想起的所有对话

Concerned itself with me and nothing else at all

除了和我相关的 什么都记不得了

The game of love I played with arrogance and pride

我用自负和傲慢玩着爱情的游戏

And every flame I lit too quickly, quickly died

所有我点燃的火焰都熄灭得太快

The friends I made all somehow seemed to slip away

所有我交的朋友似乎都不知不觉地离开了

And only now I'm left alone to end the play, yeah

只剩我一个人在台上来结束这场闹剧

Oh, yesterday when I was young

噢 昨日当我年少轻狂

So many, many songs were waiting to be sung

有那么那么多甜美的曲儿等我歌唱

So many wild pleasures lay in store for me

有那么多肆意的快乐等我享受

And so much pain my eyes refused to see

还有那么多痛苦 我的双眼却视而不见

There are so many songs in me that won't be sung

我有太多歌曲永远不会被唱起

I feel the bitter taste of tears upon my tongue

我尝到了舌尖泪水的苦涩滋味

The time has come for me to pay for yesterday

终于到了付出代价的时间 为了昨日

When I was young

当我年少轻狂

基本操作：

#date=open("yesterday",'r',encoding="utf-8").read()
f=open("yesterday",'r',encoding="utf-8")          #文件句柄
#date=f.read()                                    #一次性全读
#print(date)

#for i in range(5):
#    print(f.readline())                         #一次读一行

'''
for index,line in enumerate(f.readlines()):       #一次性全读在内存中并转成列表    占用内存很大
    if index==9:
        print("------------我是分割线-----------")
        continue
    print(line.strip())
'''

'''
count=0
for line in f:                                   #在内存中一次占用一行
    if count==9:
        print("---------我是分割线-----------")
        count+=1
        continue
    print(line)
    count+=1
'''
print(f.readline())
print(f.tell())                            #读出文件光标指针的位置
f.seek(0)                                  #将光标置为0
print(f.readline())

print(f.encoding)                          #文件使用的字符编码

print(f.fileno())                           #返回文件句柄在内存中的编号
f.flush()                                   #将缓存中的内容刷到硬盘上
f.truncate()                                #截断    什么都不写就是把文件清空   从头开始截断

打开文件的模式有：

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

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

• r+，可读写文件。【可读；可写；可追加】
• w+，写读
• a+，同a

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

• rU
• r+U

"b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）

• rb
• wb
• ab

with语句

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

1 2 3

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

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

二. 函数

1、函数是什么?

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

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

特性:

减少重复代码

使程序变的可扩展

使程序变得易维护

语法定义

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、函数参数与局部变量　　

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

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

默认参数

看下面代码

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变成默认参数后，我同时把它的位置移到了最后面，为什么呢？　　

关键参数

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

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

　　

非固定参数

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

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

局部变量　　

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

全局与局部变量

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

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

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

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

3、返回值　　

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

注意:

函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束

如果未在函数中指定return,那这个函数的返回值为None

　　

强行插入知识点: 嵌套函数　　

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

name = "Alex"

def change_name():

name = "Alex2"

def change_name2():

name = "Alex3"

print("第3层打印",name)

change_name2() #调用内层函数

print("第2层打印",name)

change_name()

print("最外层打印",name)

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

没错， 出错了， 为什么呢？

嵌套函数的用法会了，但它有什么用呢？下节课揭晓。。。

　　

4. 递归

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

def calc(n):

print(n)

if int(n/2) ==0:

return n

return calc(int(n/2))

calc(10)

输出：

10

5

2

1

递归特性:

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

堆栈扫盲http://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html

递归函数实际应用案例，二分查找

data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]

def binary_search(dataset,find_num):

print(dataset)

if len(dataset) >1:

mid = int(len(dataset)/2)

if dataset[mid] == find_num:  #find it

print("找到数字",dataset[mid])

elif dataset[mid] > find_num :# 找的数在mid左面

print("\033[31;1m找的数在mid[%s]左面\033[0m" % dataset[mid])

return binary_search(dataset[0:mid], find_num)

else:# 找的数在mid右面

print("\033[32;1m找的数在mid[%s]右面\033[0m" % dataset[mid])

return binary_search(dataset[mid+1:],find_num)

else:

if dataset[0] == find_num:  #find it

print("找到数字啦",dataset[0])

else:

print("没的分了,要找的数字[%s]不在列表里" % find_num)

binary_search(data,66)

5、匿名函数

匿名函数就是不需要显式的指定函数

#这段代码

def calc(n):

return n**n

print(calc(10))

#换成匿名函数

calc = lambda n:n**n

print(calc(10))

你也许会说，用上这个东西没感觉有毛方便呀， 。。。。呵呵，如果是这么用，确实没毛线改进，不过匿名函数主要是和其它函数搭配使用的呢，如下

res = map(lambda x:x**2,[1,5,7,4,8])

for i in res:

print(i)

输出

1

25

49

16

64

6、高阶函数

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

def add(x,y,f):

return f(x) + f(y)

res = add(3,-6,abs)

print(res)

7、函数式编程介绍：

函数是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")

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

要想学好函数式编程，不要玩py,玩Erlang,Haskell, 好了，我只会这么多了。。。