with open（）as

def delete(ps):
import os
filename=ps[-1]
delelemetns=ps[1]
with open(“C:\Users\Administer\Desktop\test1.fa”,encoding=‘utf-8’) as f_read,
open(‘C:\Users\Administer\Desktop\tmp.txt’,‘w’,encoding=‘utf-8’) as f_write:
for line in iter(f_read.readline,’’):
if line !=’\n’:
if delelemetns in line:#delelemetns
line=line.replace(delelemetns,’’)
f_write.write(line)

ps=GGGGGG
Traceback (most recent call last):
File “<pyshell#18>”, line 1, in
ps=GGGGGG
NameError: name ‘GGGGGG’ is not defined

ps=“GGGGGG”
s=delete(ps)
line=“ATCTCACCCAAAATATACACACCTTCTACTATTTCTCCATATTCATCTACTTCTAATCA”
delelemetns=“g”
line=line.replace(delelemetns,’’)
line
‘ATCTCACCCAAAATATACACACCTTCTACTATTTCTCCATATTCATCTACTTCTAATCA’

line=“ATCTCACCCAAAATATACACACCTTCTACTATTTCTCCATATTCATCTACTTCTAATCG”
delelemetns=“g”
line=line.replace(delelemetns,’’)
line
‘ATCTCACCCAAAATATACACACCTTCTACTATTTCTCCATATTCATCTACTTCTAATCG’

line=“ATCTCACCCAAAATATACACACCTTCTACTATTTCTCCATATTCATCTACTTCTAATCg”
delelemetns=“g”
line=line.replace(delelemetns,’’)
line
‘ATCTCACCCAAAATATACACACCTTCTACTATTTCTCCATATTCATCTACTTCTAATC’

addelemetns=“K”
with open(“C:\Users\Administer\Desktop\tmp.txt”,‘a’,encoding=‘utf-8’) as fp:
fp.write(addelemetns)

1

inp = input(“请输入您要进行的操作:”).strip()
请输入您要进行的操作:delete

inp
‘delete’

cmd_1 = inp.split()
cmd_1
[‘delete’]

cmd = cmd_1[0]
cmd
‘delete’

dic_func ={‘delete’: delete}
dic_func[cmd]
<function delete at 0x0393EDB0>

dic_funccmd
Traceback (most recent call last):
File “<pyshell#62>”, line 1, in
dic_funccmd
File “<pyshell#17>”, line 4, in delete
delelemetns=ps[1]
IndexError: list index out of range

delete
<function delete at 0x0393EDB0>

cmd_1
[‘delete’]

ps=cmd_1
ps
[‘delete’]

filename = ps[-1]
filename
‘delete’

b.函数名可以作为返回值

def outer():
def inner():
pass
return inner
s = outer()
print(s)
######输出结果为#######
<function outer.<locals="">.inner at 0x000000D22D8AB8C8>
c.函数名可以作为一个参数

def index():
print(“index func”)
def outer(index):
s = index
s()
outer(index)
######输出结果#########
index func
所以满足上面两个条件中的一个,都可以称为高级函数.

def outer():

x = 1
def inner():
print(“x=%s” %x)
print(“inner func excuted”)
print(“outer func excuted”)
return inner # 返回内部函数名
outer()
现在我们来抽象的定义一下闭包函数。它是函数和与其相关的引用环境组合而成的实体。在实现深约束时，需要创建一个能显式表示引用环境的东西，并将它与相关的子程序捆绑在一起，这样捆绑起成为闭包。在上面实例中，我们可以发现,闭包函数,它必须包含自己的函数以及一个外部变量才能真正称得上是一个闭包函数。如果没有一个外部变量与其绑定,那么這个函数不能算得上是闭包函数。

闭包函数的特点：1.自带作用域 2.延迟计算

那么闭包函数有什么作用呢?我们清楚的知道，闭包函数在定义时，一定会绑定一个外部环境。這个整体才能算的上是一个闭包函数，那么我们可以利用这个绑定特性，来完成某些特殊的功能。

实例三：根据传入的URL,来下载页面源码

from urllib.request import urlopen
def index(url)
def get()
return urlopen(url).read()
return get
python = index(“http://www.python.org”) # 返回的是get函数的地址
print(python()) # 执行get函数《并且将返回的结果打印出来
baidu = index(“http://www.baidu.com”)
print(baidu())
有人可以会说,这个不满足闭包函数的条件啊!我没有引用非全局的外部变量啊。其实并非如此,给，我们之前说过,只要在函数内部的变量都属于函数。那么我在index(url)，这个url也属于函数内部，只不过我们省略一步而已，所以上面那个函数也是闭包函数。

四.装饰器

有了以上基础,对于装饰器就好理解了.

装饰器：外部函数传入被装饰函数名，内部函数返回装饰函数名。

特点：1.不修改被装饰函数的调用方式 2.不修改被装饰函数的源代码

import time, random
def outer(func):# 将index的地址传递给func
def inner():
start_time=time.time()
func()# fun= index 即func保存了外部index函数的地址
end_time=time.time()
print(“运行时间为%s”%(end_time - start_time))
return inner# 返回inner的地址

def index():
time.sleep(random.randrange(1, 5))
print(“welcome to index page”)

index = outer(index) # 这里返回的是inner的地址，并重新赋值给index
index()
welcome to index page
运行时间为3.0422751903533936

如果一个函数被多个装饰器装饰,那么执行顺序是怎样的。

import time
import random
def timmer(func):
def wrapper():
start_time = time.time()
func()
stop_time=time.time()
print(‘run time is %s’ %(stop_time-start_time))
return wrapper
def auth(func):
def deco():
name=input('name: ')
password=input('password: ')
if name == ‘egon’ and password == ‘123’:
print(‘login successful’)
func() #wrapper()
else:
print(‘login err’)
return deco
@auth # index = auth(timmer(index))
@timmer # index = timmer(index)
def index():
time.sleep(3)
print(‘welecome to index page’)
index()
  实验结果表明,多个装饰器装饰一个函数,其执行顺序是从下往上。