python（three）

一。函数与函数式编程
1. 函数
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如
print()。但你也可以自己创建函数，这被叫做用户自定义函数。
2.过程与函数
1.面向对象 ： 类（class）
2.面向过程： 过程 （def）（无返回值） 3.函数式编程 ： 函数（def）（有返回值）
3.在编程中，过程和函数都是可以调运的实体，将没有返回值的函数叫做过程。
过程与函数

        #函数 
def fun1(): 
"""testing01""" 
print("this is a testing1") 
return 0 
#过程 
def fun2(): 
"""testing02""" 
print("this is a testing2") 
x = fun1() 
y = fun2() 

3. 为什么使用函数
1.代码重用
2.保持一致性
3.可扩展
4.定义一个函数
你可以定义一个由自己想要功能的函数，以下是简单的规则：
1.函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
2.任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
3.函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
4.函数内容以冒号起始，并且缩进。
5.return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回
None。
5.语法
def 函数名（参数列表）：
函数体
例：

def hello():
     print("hello world") 
 hello()

6.返回值
1.return执行的效果是：返回一个值，且终止当前程序运行。

def test1():
     print("in the test1")
     return 0
 print("test end")
x = test1
print(x)

2.返回值类型

import time     #导入模块
def test1():
    '''XXXX'''          #说明
    time_format = '%Y-%m-%d %X'    #引用时间戳
    time_current = time.strftime(time_format)
    print(time_current)
    print("This is a test1...")


def test2():
    '''XXXX'''          #说明
    time_format = '%Y-%m-%d %X'    #引用时间戳
    time_current = time.strftime(time_format)
    print(time_current)
    print("This is a test1...")

def test3():
    '''XXXX'''  # 说明
    time_format = '%Y-%m-%d %X'  # 引用时间戳
    time_current = time.strftime(time_format)
    print(time_current)
    print("This is a test1..")

test1()
test2()
test3()

当没有返回值时，返回NUll。
当返回值时一个特定值时，返回这个值。
当返回值是多个值时，返回的是一个元组。
当返回值是一个函数名时，返回的是函数的内存地址。
当返回值时一个函数时，返回值时函数的执行结果
7.函数调运
位置参数
关键字参数
默认参数
参数组

#Author:Anliu 
def test(x,y): #形参 
print(x) 
print(y) 
#test("x","y") #位置实参调运,形参和实参是一一对应 
#test(y=2,x=3) #关键字参数调运，与形参位置无关。 
test(x=2,3) #关键参数不能写在位置参数之前。 
#test(3,y=2) #位置参数和关键字参数同时存在，以位置参数调运为主。

（1）位置实参调运,形参和实参是一一对应
（2）关键字参数调运，与形参位置无关。
（3）关键字参数不能写在位置参数之前。
（4）位置参数和关键字参数同时存在，以位置参数调运为主。
8.变量
在函数内是不能修改全局变量的值

#Author:Anliu 
school = "xiyunkeji" #全局变量 
def change_name(name): 
school = "baiyijishu" #在函数内是不能修改全局变量的值 
print("before change",name,school) 
name = "Auliu" #局部变量，这个函数就是变量的作用域 
print("after change",name) 
name = "anliu" 
change_name(name) 
print(name,school)

定义global之后，全局变量也是可以在函数内修改的。

#Author:Anliu 
school = "xiyunkeji" #全局变量 
def change_name(name): 
global school #定义global之后，全局变量也是可以在函数内修改的。 
school = "baiyijishu" #在函数内是不能修改全局变量的值 
print("before change",name,school) 
name = "Auliu" #局部变量，这个函数就是变量的作用域 
print("after change",name) 
name = "anliu" 
change_name(name) 
print(name,school)

当全局变量为列表，字典，集合包括类，这种复杂的数据类型及数据结果，函数中也是
可以修改全局变量的。
9.递归函数
在函数内部，可以调运其他函数。如果一个函数在内部调运自身，这个函数就是递归函数。
递归的特性：
1.必须要有一个明确的结束条件。
2.每次进入更深的一层递归时，问题规模相比上次都应有所减少。
3.递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调运是通过栈（stack）这种数据结构
实现的，每当进入一个函数调运，栈就会加一层栈帧。每当函数返回，栈就会减少一层栈帧。由于栈的
大小不是无限的，所以，递归调运的次数过多，会导致栈溢出）

def calc(n): 
print(n) 
if int(n/2) > 0: 
return calc(int(n/2)) 
print("-->",n) 
calc(10)

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

def add(a,b,f)
    return f(a) + f(b)
x = add(1,-6,abs)
print(x)

以上abs是求绝对值的函数。
11.匿名函数

calc = lambda x：x*3
print(calc(2))

12.高阶函数
把一个函数名当做实参传递给另一个函数

返回值中包含函数名

def test1(func):
print(func)
def bar():
print("in the bar")
test1(bar)
func = bar
func()

13.嵌套函数
在一个函数体内定义另一个函数

import time

def timer(func):
    def logges(*args,**kwargs):
        format_time = "%Y-%m-%d %X"
        time_current = time.strftime(format_time)
        print(time_current)
        func(*args,**kwargs)
    return logges
@timer
def test1():
    '''#######'''
    print("good...")
test1()```
**14.装饰器**
装饰器=高阶函数+嵌套函数

```javascript
import time

def timer(func):
    def logges(*args,**kwargs):
        format_time = "%Y-%m-%d %X"
        time_current = time.strftime(format_time)
        print(time_current)
        func(*args,**kwargs)
    return logges
@timer
def test1():
    '''#######'''
    print("good...")
test1()

二.文件
文件操作的流程：
1.打开文件，得到文件句柄并赋值给变量。
2.通过句柄对文件进行操作。
3.关闭文件。
2.从文件中读取数据

#Author:Anliu 
with open("..\DIR_file\pi_digits",encoding=("utf-8")) as file_object:    
	lines = file_object.readlines()   
 	print(lines) 
 for line in lines:    
	 print(line.rstrip())

3.读取整个文件
首先创造一个文件：pi_digits
《再别康桥》
作者：徐志摩
轻轻的我走了,
正如我轻轻的来；
我轻轻的招手,作别西天的云彩。
那河畔的金柳,是夕阳中的新娘；
波光里的艳影,在我的心头荡漾。
软泥上的青荇,油油的在水底招摇；
在康河的柔波里,我甘心做一条水草!
那榆荫下的一潭,不是清泉,是天上虹揉碎在浮藻间,沉淀着彩虹似的梦。
寻梦?撑一支长篙,向青草更青处漫溯,满载一船星辉,在星辉斑斓里放歌。
但我不能放歌,悄悄是别离的笙箫；
夏虫也为我沉默,沉默是今晚的康桥。

#Author:Anliu
 with open("pi_digits",encoding=("utf-8")) as file_object:
  contents =file_object.read()
   print(contents)

文件读取的原理，文件读取本质上是文件指针的移动：

f = open("shige","r",encoding="utf-8")
 print(f.tell())
 #print(f.read(5))  #读了多上个字符 
 #print(f.tell())   #记录指针位置
 print(f.readline()) 
 print(f.readline()) 
 print(f.readline()) 
 f.seek(0)
 print(f.readline())

4. 遍历全文：

f = open("shige","r",encoding="utf-8") 
for line in f.readlines(): 
print(line.strip()) 
f.close() 

5读文件的前五行：

f = open("shige","r",encoding="utf-8") 
for i in range(5): 
print(f.readline()) 
f.close() 

6第十行不打印：

f = open("shige","r",encoding="utf-8") 
for index,line in enumerate(f.readlines()): 
if index == 9: 
print("----------------分割线——————————————") 
continue 
print(line.strip())

7.写入文件
w：以写入方式打开文件
r+：读取和写入
w+：先创建新文件，在写入
a+：追加读写
wb：写入二进制文件
8.文件的强制持久化
安装软件的时候，出现的进度条，实际上就是这种持续刷新的过程。

#!/bin/python 
import sys,time 
for i in range(20):  
  sys.stdout.write("#")  
    sys.stdout.flush()   
     time.sleep(0.1) 

9.文件截断

f = open("shige","a",encoding="utf-8")
 f.truncate(20)

10.修改文件
（1）将文件加载到内存中，在内存中修改
（2）打开一个新文件，在新文件中修改

f = open("write_file","r",encoding="utf-8") 
f_new = open("write_file.bak","w",encoding="utf-8")
for line in f:   
	if "徐志摩" in line:     
    	line = line.replace("徐志摩","anliu")  
    f_new.write(line)
 
f.close()
 f_new.close()