python函数编程闯关总结
Posted tu240302975
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python函数编程闯关总结相关的知识，希望对你有一定的参考价值。
文件处理相关
1，编码问题
（1）请问python2与python3中的默认编码是什么？
python 2.x默认的字符编码是ASCII，默认的文件编码也是ASCII python 3.x默认的字符编码是unicode，默认的文件编码也是utf-8
（2）为什么会出现中文乱码，你能举例说明乱码的情况有哪几种？
无论以什么编码在内存里显示字符，存到硬盘上都是2进制，所以编码不对，程序就会出错了。
ascii编码（美国）
GBK编码（中国）
shift_JIS编码（日本）
要注意的是，存到硬盘上时是以何种编码存的，再从硬盘上读出来时，就必须以何种编码读，要不然就乱了。。
常见的编码错误的原因有:
python解释器的默认编码
Terminal使用的编码
python源文件文件编码
操作系统的语言设置,掌握了编码之前的关系后,挨个排错就ok
（3）如何进行编码转换？
如果想要中国的软件可以正常的在美国人的电脑上实现，有下面两种方法： 1，让美国人的电脑都装上gbk编码 2，让你的软件编码以utf-8编码 第一种方法不可现实，第二种方法比较简单，但是也只能针对新开发的软件， 如果你之前开发的软件就是以gbk的编码写的，上百万行代码已经写出去了， 重新编码成utf-8格式也会费很大力气。 所以，针对已经用gbk开发的软件项目如何让项目在美国人的电脑上正常显示 还记得unicode的一个功能就是其包含了跟全球所有国家编码的映射关系， 所以无论你以什么编码存储的数据，只要我们的软件把数据从硬盘上读到内存， 转成unicode来显示即可，由于所有的系统，编程语言都默认支持unicode， 所有我们的gbk软件放在美国电脑上，加载到内存里面，变成了unicode，中文就可正常展示
（4）#_*_coding:utf-8_*_ 的作用是什么？
#_*_coding:utf-8 _*_ 的作用是.py文件是什么编码，就需要告诉python用什么编码去读取这个.py文件
（5）解释python2.x bytes与python3.x bytes的区别
简单点说： Python 2 将 strings 处理为原生的 bytes 类型，而不是 unicode， Python 3 所有的 strings 均是 unicode 类型。
在python2.x中，写字符串，比如 >>>s = ”学习“ >>>print s 学习 >>>s ‘xd1xa7xcfxb0‘ 虽然说打印的是学习，但是直接调用的变量s，确实一个个16进制表示的二进制字节， 我们称这个为byte类型，即字节类型，它把8个二进制一组称为一个byte，用16进制表示 所以说python2.x的字符串其实更应该称为字符串，通过存储的方式就能看出来， 但是在python2.x中还有一个bytes类型，两个是否相同呢，回答是肯定的，在python2.x中，bytes==str python3.x中 把字符串变成了unicode，文件默认编码编程了utf-8，这意味着，只要用python3.x， 无论我们的程序以那种语言开发，都可以在全球各国电脑上正常显示。 python3.x除了把字符串的编码改成了unicode，还把str和bytes做了明确区分， str就是unicode格式的字符串bytes就是单纯的二进制 （补充一个问题，为什么在python3.x中，把unicode编码后，字符串就变成了bytes格式 ，为什么不直接打印成gbk的字符，我觉得就是想通过这样的方式明确的告诉你，想在python3.x中看字符， 必须是unicode，其他编码一律是bytes格式）
2，文件处理
（1） r和rb的区别是什么？
文件操作时候，以“r"或者”rb"模式打开，只能读取，无法写入； 硬盘上保存的文件都是某种编码的0101010，打开时需要注意： rb，直接读取文件保存时原生的0101010，在Python中用字节类型表示 r和encoding，读取硬盘的0101010，并按照encoding指定的编码格式进行断句， 再将“断句”后的每一段0101010转换成unicode的 010101010101，在Python中用字符串类型表示
（2）解释一下下面三个参数的作用分别是什么？
open(f_name,‘r‘,encoding="utf-8")
f_name 是文件的路径，mode是打开的方式，encoding是编码格式
encoding #文件编码
mode #打开模式
name #文件名
newlines #文件中用到的换行模式，是一个tuple
softspace #boolean型，一般为0，据说用于print
（3） w和wb的区别是什么？
文件操作时候，以 “w”或“wb” 模式打开，则只能写，并且在打开的同时会先将内容清空。 写入到硬盘上时，必须是某种编码的0101010，打开时需要注意： wb，写入时需要直接传入以某种编码的0100101，即：字节类型 w 和 encoding，写入时需要传入unicode字符串，内部会根据encoding制定的编码 将unicode字符串转换为该编码的 010101010
（4）a和ab的区别是什么？
文件操作时，以 “a”或“ab” 模式打开，则只能追加，即：在原来内容的尾部追加内容 写入到硬盘上时，必须是某种编码的0101010，打开时需要注意： ab，写入时需要直接传入以某种编码的0100101，即：字节类型 a 和 encoding，写入时需要传入unicode字符串，内部会根据encoding制定的编码 将unicode字符串转换为该编码的 010101010
（5）readline和readlines的区别
readline() #读取一行
readlines() #读取所有内容，并返回列表（一行为列表的一个元素值）
（6）全局替换程序：
写一个脚本，允许用户按以下方式执行时，即可以对指定文件内容进行全局替换
`python your_script.py old_str new_str filename`
替换完毕后打印替换了多少处内容
（7）模拟登陆
- 用户输入帐号密码进行登陆
- 用户信息保存在文件内
- 用户密码输入错误三次后锁定用户，下次再登录，检测到是这个用户也登录不了
函数基础
1，写函数，计算传入数字参数的和。（动态传参）
#写函数，计算传入数字参数的和。（动态传参）
x = int(input("输入要计算的值x: ")) #定义动态输入的x值
y = int(input("输入要计算的值y: ")) #定义动态输入的y值
def calc(x,y):
result = x+y
return ("结果是：",result)
a = calc(x,y)
print(a)
# 输入要计算的值x: 123
# 输入要计算的值y: 456
# (‘结果是：‘, 579)
2，写函数，用户传入修改的文件名，与要修改的内容，执行函数，完成整个文件的批量修改操作
# 2、写函数，用户传入修改的文件名，与要修改的内容，执行函数，完成整个文件的批量修改操作
import os
file_name = "print_tofile.txt"
file_new_name = ‘%s.new‘ %file_name
old_str = ‘最近学习不太好‘
new_str = ‘最近学习真不好‘
f_old = open(file_name,‘r‘,encoding=‘utf-8‘)
f_new = open(file_new_name,‘w‘,encoding=‘utf-8‘)
for line in f_old:
if old_str in line:
line = line.replace(old_str,new_str)
f_new.write(line)
print(line)
f_old.close()
f_new.close()
os.replace(file_new_name,file_name)
import os
def update_func(a: object, old_str: object, new_str: object) -> object: #定义三个接受值的形参，a是要修改的文件名，b是要修改的内容，c是修改后的内容
#打开文件，文件名为接受的形参a
file_old = ‘a.txt‘
file_new = ‘aa.txt‘
f_old = open(file_old,‘r‘,encoding=‘utf-8‘)
#打开修改后写入的文件
f_new = open(file_new,‘w‘,encoding=‘utf-8‘)
# old_str = ‘你是我唯一的爱‘
# new_str = ‘you are my everything‘
#循环每一行的文件的数据
for line in f_old:
new_content = line.replace(old_str,new_str) #将要修改的内容字符串用replace替换
f_new.write(new_content) #将替换后的内容写入修改后写入的文件中
f_new.close()
f_old.close()
os.replace(file_new,file_old)
update_func(‘a.txt‘,‘你是我唯一的爱‘,‘you are my everything‘)
修改前的文件内容：
你是我唯一的爱，you are my everything
修改后的文件内容：
you are my everything，you are my everything
3，写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容。
def check_str(a): #a为传过来的参数
calc = False #空格统计默认False没有
for line in a:
if line.isspace():
calc = True
return calc
a = ‘123 132 456 7489 456‘
res = check_str(a)
print(res)
def func(strr,listt,tuplee):
if strr.isspace():
print("字符串有空内容")
else:
print("字符串里面没有空内容")
if len(listt) ==0:
print("列表有空内容")
else:
print("列表里面没有空内容")
if len(tuplee) == 0:
print("元祖有空内容")
else:
print("元组里面没有空内容")
res = func(‘123456‘,[],())
# 字符串里面没有空内容
# 列表有空内容
# 元祖有空内容
4，写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
dic = {"k1": "v1v1", "k2": [11,22,33,44]}
PS:字典中的value只能是字符串或列表
# 4，写函数，检查传入字典的每一个value的长度,如果大于2，
# 那么仅保留前两个长度的内容，并将新内容返回给调用者。
dic = {"k1": "v1v1", "k2": [11,22,33,44]}
def check_func(a): #a为传过来的参数
li = []
for item in a.values():
length = len(item)
if length >2:
li.append(item[0:2])
else:
continue
return li
a = check_func(dic)
print(a)
# [‘v1‘, [11, 22]]
5，解释闭包的概念
关于闭包，即函数定义和函数表达式位于另一个函数的函数体内（嵌套函数）。而且这些内部函数可以访问他们所在的外部函数中声明的所有局部变量，参数。当其中一个这样的内部函数在包含他们的外部函数之外被调用时候，就形成了闭包。
也就是说，内部函数会在外部函数返回后被执行。而当这个内部函数执行的时候，它仍然必需访问其外部函数的局部变量，参数以及其他内部函数，这些局部变量，参数声明（最初时）的值是外部函数返回时候的值，但也会受到内部函数的影响。 闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域
简单的说，闭包就是一个内部函数+外部环境
6，写函数，计算传入字符串中的【数字】、【字母】、【空格】和【其他】的个数
# 6，写函数，计算传入字符串中的【数字】、【字母】、【空格】和【其他】的个数
def func(strr):
digit_number = 0
space_number = 0
alpha_number = 0
else_number = 0
for i in strr:
if i.isdigit():
digit_number +=1
elif i.isspace():
space_number +=1
elif i.isalpha():
alpha_number +=1
else:
else_number +=1
return ("数字，空格，字母，其他内容分别有：",(digit_number,space_number,alpha_number,else_number))
res = func(‘sda!@#$%^&1234567dfghj da da ‘)
print(res)
# (‘数字，空格，字母，其他内容分别有：‘, (7, 3, 12, 7))
函数进阶
1，写函数，返回一个扑克牌列表，里面有52项，每一项是一个元组
例如：[(‘红心’，2),(‘草花’，2), …(‘黑桃A’)]
def cards():
num = []
for i in range(2,11):
num.append(i)
num.extend([‘J‘,‘Q‘,‘K‘,‘A‘])
type = [‘红心‘,‘草花‘,‘方块‘,‘黑桃‘]
result = []
for i in num:
for j in type:
result.append((j,i))
return result
print(cards())
# [(‘红心‘, 2), (‘草花‘, 2), (‘方块‘, 2), (‘黑桃‘, 2),
# (‘红心‘, 3), (‘草花‘, 3), (‘方块‘, 3), (‘黑桃‘, 3),
# (‘红心‘, 4), (‘草花‘, 4), (‘方块‘, 4), (‘黑桃‘, 4),
# (‘红心‘, 5), (‘草花‘, 5), (‘方块‘, 5), (‘黑桃‘, 5),
# (‘红心‘, 6), (‘草花‘, 6), (‘方块‘, 6), (‘黑桃‘, 6),
# (‘红心‘, 7), (‘草花‘, 7), (‘方块‘, 7), (‘黑桃‘, 7),
# (‘红心‘, 8), (‘草花‘, 8), (‘方块‘, 8), (‘黑桃‘, 8),
# (‘红心‘, 9), (‘草花‘, 9), (‘方块‘, 9), (‘黑桃‘, 9),
# (‘红心‘, 10), (‘草花‘, 10), (‘方块‘, 10), (‘黑桃‘, 10),
# (‘红心‘, ‘J‘), (‘草花‘, ‘J‘), (‘方块‘, ‘J‘), (‘黑桃‘, ‘J‘),
# (‘红心‘, ‘Q‘), (‘草花‘, ‘Q‘), (‘方块‘, ‘Q‘), (‘黑桃‘, ‘Q‘),
# (‘红心‘, ‘K‘), (‘草花‘, ‘K‘), (‘方块‘, ‘K‘), (‘黑桃‘, ‘K‘),
# (‘红心‘, ‘A‘), (‘草花‘, ‘A‘), (‘方块‘, ‘A‘), (‘黑桃‘, ‘A‘)]
2，写函数，传入n个数，返回字典{‘max’:最大值,’min’:最小值}
例如:min_max(2,5,7,8,4)
返回:{‘max’:8,’min’:2}
# 2，写函数，传入n个数，返回字典{‘max’:最大值,’min’:最小值}
# 例如:min_max(2,5,7,8,4)
# 返回:{‘max’:8,’min’:2}
def max_min(*args):
the_max = args[0]
the_min = args[0]
for i in args:
if i>the_max:
the_max = i
else:
the_min = i
return {‘max‘:the_max,‘min‘:the_min}
res = max_min(2,4,6,48,-16,486)
print(res)
# {‘max‘: 486, ‘min‘: -16}
3，写函数，专门计算图形的面积
- 其中嵌套函数，计算圆的面积，正方形的面积和长方形的面积
- 调用函数area(‘圆形’,圆半径) 返回圆的面积
- 调用函数area(‘正方形’,边长) 返回正方形的面积
- 调用函数area(‘长方形’,长，宽) 返回长方形的面积
def area():
def 计算长方形面积():
pass
def 计算正方形面积():
pass
def 计算圆形面积():
pass
import math
print(‘‘‘
请按照如下格式输出：
调用函数area(‘圆形’,圆半径) 返回圆的面积
调用函数area(‘正方形’,边长) 返回正方形的面积
调用函数area(‘长方形’,长，宽) 返回长方形的面积‘‘‘)
def area(name,*args):
def areas_rectangle(x,y):
return ("长方形的面积为：",x*y)
def area_square(x):
return ("正方形的面积为：",x**2)
def area_round(r):
return ("圆形的面积为：",math.pi*r*r)
if name ==‘圆形‘:
return area_round(*args)
elif name ==‘正方形‘:
return area_square(*args)
elif name ==‘长方形‘:
return areas_rectangle(*args)
print(area(‘长方形‘, 3, 4))
print(area(‘圆形‘, 3))
print(area(‘正方形‘, 3))
# 请按照如下格式输出：
# 调用函数area(‘圆形’,圆半径) 返回圆的面积
# 调用函数area(‘正方形’,边长) 返回正方形的面积
# 调用函数area(‘长方形’,长，宽) 返回长方形的面积
# (‘长方形的面积为：‘, 12)
# (‘圆形的面积为：‘, 28.274333882308138)
# (‘正方形的面积为：‘, 9)
4，写函数，传入一个参数n，返回n的阶乘
例如:cal(7) 计算7*6*5*4*3*2*1
# 4、写函数，传入一个参数n，返回n的阶乘。
# 例如: cal(7） 计算7 * 6 * 5 * 4 * 3 * 2 * 1
def cal(n):
res= 1
for i in range(n,0,-1):
# print(i)
res = res*i
print(res)
return res
print(cal(7))
5，编写装饰器，为多个函数加上认证的功能（用户的账号密码来源于文件），要求登录成功一次，后续的函数都无需再输入用户名和密码
# 5，编写装饰器，为多个函数加上认证的功能（用户的账号密码来源于文件），
# 要求登录成功一次，后续的函数都无需再输入用户名和密码
def login(func):
def wrapper(*args,**kwargs):
username = input("account:").strip()
password = input("password:").strip()
with open(‘userinfo.txt‘,‘r‘,encoding=‘utf-8‘) as f:
userinfo = f.read().strip(‘,‘)
userinfo = eval(userinfo)
print(userinfo)
if username in userinfo[‘name‘] and password in userinfo[‘password‘]:
print("success")
else:
print("pass")
return wrapper
@login
def name():
print("hello")
name()
生成器和迭代器
1，生成器和迭代器的区别？
对于list、string、tuple、dict等这些容器对象,使用for循环遍历是很方便的。在后台for语句对容器对象调用iter()函数。iter()是python内置函数。
iter()函数会返回一个定义了 next()方法的迭代器对象，它在容器中逐个访问容器内的元素。next()也是python内置函数。在没有后续元素时，next()会抛出一个StopIteration异常，通知for语句循环结束。 迭代器是用来帮助我们记录每次迭代访问到的位置，当我们对迭代器使用next()函数的时候，迭代器会向我们返回它所记录位置的下一个位置的数据。实际上，在使用next()函数的时候，调用的就是迭代器对象的_next_方法（Python3中是对象的_next_方法，Python2中是对象的next()方法）。
所以，我们要想构造一个迭代器，就要实现它的_next_方法。但这还不够，python要求迭代器本身也是可迭代的，所以我们还要为迭代器实现_iter_方法，而_iter_方法要返回一个迭代器，迭代器自身正是一个迭代器，所以迭代器的_iter_方法返回自身self即可。
2，生成器有几种方式获取value？
两种方式获取：
for 循环
next 获取
3，通过生成器写一个日志调用方法， 支持以下功能
- 根据指令向屏幕输出日志
- 根据指令向文件输出日志
- 根据指令同时向文件&屏幕输出日志
- 以上日志格式如下
2017-10-19 22:07:38 [1] test log db backup 3 2017-10-19 22:07:40 [2] user alex login success #注意：其中[1],[2]是指自日志方法第几次调用，每调用一次输出一条日志
代码结构如下：
def logger(filename,channel=‘file‘):
"""
日志方法
:param filename: log filename
:param channel: 输出的目的地，屏幕(terminal)，文件(file)，屏幕+文件(both)
:return:
"""
...your code...
#调用
log_obj = logger(filename="web.log",channel=‘both‘)
log_obj.__next__()
log_obj.send(‘user alex login success‘)
内置函数
1，用map来处理字符串列表,把列表中所有人都变成sb,比方alex_sb
name=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,‘nezha‘]
map()函数 map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把 函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。
注意：map()函数在不改变原有的list，而是返回一个新的list
# 1，用map来处理字符串列表,把列表中所有人都变成sb,比方alex_sb
# name=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,‘nezha‘]
name=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,‘nezha‘]
def sb(x):
return x+‘_sb‘
res = map(sb,name)
print(list(res))
# 结果：
[‘alex_sb‘, ‘wupeiqi_sb‘, ‘yuanhao_sb‘, ‘nezha_sb‘]
2，用filter函数处理数字列表，将列表中所有的偶数筛选出来
num = [1,3,5,6,7,8]
# 2，用filter函数处理数字列表，将列表中所有的偶数筛选出来
# num = [1,3,5,6,7,8]
num = [1,3,5,6,7,8]
def func(x):
if x%2 == 0:
return True
ret = filter(func,num)
print(list(ret))
# 结果：
[6, 8]
3，如下，每个小字典的name对应股票名字，shares对应多少股，price对应股票的价格
portfolio = [
{‘name‘: ‘IBM‘, ‘shares‘: 100, ‘price‘: 91.1},
{‘name‘: ‘AAPL‘, ‘shares‘: 50, ‘price‘: 543.22},
{‘name‘: ‘FB‘, ‘shares‘: 200, ‘price‘: 21.09},
{‘name‘: ‘HPQ‘, ‘shares‘: 35, ‘price‘: 31.75},
{‘name‘: ‘YHOO‘, ‘shares‘: 45, ‘price‘: 16.35},
{‘name‘: ‘ACME‘, ‘shares‘: 75, ‘price‘: 115.65}
]
计算购买每支股票的总价
用filter过滤出，单价大于100的股票有哪些
# 3，如下，每个小字典的name对应股票名字，shares对应多少股，price对应股票的价格
portfolio = [
{‘name‘: ‘IBM‘, ‘shares‘: 100, ‘price‘: 91.1},
{‘name‘: ‘AAPL‘, ‘shares‘: 50, ‘price‘: 543.22},
{‘name‘: ‘FB‘, ‘shares‘: 200, ‘price‘: 21.09},
{‘name‘: ‘HPQ‘, ‘shares‘: 35, ‘price‘: 31.75},
{‘name‘: ‘YHOO‘, ‘shares‘: 45, ‘price‘: 16.35},
{‘name‘: ‘ACME‘, ‘shares‘: 75, ‘price‘: 115.65}
]
#
# 计算购买每支股票的总价
# 用filter过滤出，单价大于100的股票有哪些
portfolio = [
{‘name‘: ‘IBM‘, ‘shares‘: 100, ‘price‘: 91.1},
{‘name‘: ‘AAPL‘, ‘shares‘: 50, ‘price‘: 543.22},
{‘name‘: ‘FB‘, ‘shares‘: 200, ‘price‘: 21.09},
{‘name‘: ‘HPQ‘, ‘shares‘: 35, ‘price‘: 31.75},
{‘name‘: ‘YHOO‘, ‘shares‘: 45, ‘price‘: 16.35},
{‘name‘: ‘ACME‘, ‘shares‘: 75, ‘price‘: 115.65}
]
m = map(lambda y:y[‘shares‘]*y[‘price‘],portfolio)
print(list(m))
# [9110.0, 27161.0, 4218.0, 1111.25, 735.7500000000001, 8673.75]
a = []
for index,i in enumerate(portfolio):
res= i[‘shares‘] * i[‘price‘]
a.append(res)
print(a)
# [9110.0, 27161.0, 4218.0, 1111.25, 735.7500000000001, 8673.75]
# 3、用filter过滤出，单价大于100的股票有哪些
f = filter(lambda d:d[‘price‘]>=100,portfolio)
print(list(f))
# [{‘name‘: ‘AAPL‘, ‘shares‘: 50, ‘price‘: 543.22}, {‘name‘: ‘ACME‘, ‘shares‘: 75, ‘price‘: 115.65}]
其他练习
1，有列表 li = [‘alex‘, ‘egon‘, ‘smith‘, ‘pizza‘, ‘alen‘], 请将以字母“a”开头的元素的首字母改为大写字母；
# 1，有列表 li = [‘alex‘, ‘egon‘, ‘smith‘, ‘pizza‘, ‘alen‘],
# 请将以字母“a”开头的元素的首字母改为大写字母；
li = [‘alex‘, ‘egon‘, ‘smith‘, ‘pizza‘, ‘alen‘]
li_new = []
for i in li:
if i.startswith(‘a‘):
li_new.append(i.capitalize())
else:
li_new.append(i)
print(li_new)
for i in range(len(li)):
if li[i][0] == ‘a‘:
li[i] = li[i].capitalize()
else:
continue
print(li)
2，有如下程序, 请给出两次调用show_num函数的执行结果，并说明为什么：
num = 20
def show_num(x=num):
print(x)
show_num()
num = 30
show_num()
如果函数收到的是一个不可变对象（比如数字、字符或者元组）的引用，就不能直接修改原始对象，相当于通过“传值’来传递对象，此时如果想改变这些变量的值，可以将这些变量申明为全局变量。
3，有列表 li = [‘alex‘, ‘egon‘, ‘smith‘, ‘pizza‘, ‘alen‘], 请以列表中每个元素的第二个字母倒序排序；
li = [‘alex‘, ‘egon‘, ‘smith‘, ‘pizza‘, ‘alen‘] print(list(sorted(li,key=lambda x :x[1],reverse=True)))
4，有名为poetry.txt的文件，其内容如下，请删除第三行；
昔人已乘黄鹤去，此地空余黄鹤楼。 黄鹤一去不复返，白云千载空悠悠。 晴川历历汉阳树，芳草萋萋鹦鹉洲。 日暮乡关何处是？烟波江上使人愁。
# 4，有名为poetry.txt的文件，其内容如下，请删除第三行；
# 方法一：
# import os
# p = ‘poetry.txt‘
# file = open(p,‘r‘,encoding=‘utf-8‘)
# print(file)
# pnew = ‘%s.new‘%p
# filenew = open(pnew,‘w‘,encoding=‘utf-8‘)
# str1 = ‘晴川历历汉阳树，芳草萋萋鹦鹉洲。‘
# for i in file:
# if str1 in i:
# i = ‘‘
# filenew.write(i)
# else:
# filenew.write(i)
# file.close()
# filenew.close()
# os.replace(pnew,p)
# 方法二：逐行读取文件
import os
f1=open(‘poetry.txt‘, ‘r‘,encoding=‘utf-8‘)
str=‘晴川历历汉阳树，芳草萋萋鹦鹉洲。‘
with open(‘poetry1.txt‘, ‘w‘, encoding=‘utf-8‘) as f2:
ff1=‘poetry.txt‘
ff2=‘poetry1.txt‘
for line in f1:
if str in line:
line=‘‘
f2.write(line)
else:
f2.write(line)
f1.close()
f2.close()
os.replace(ff2,ff1)
5，有名为username.txt的文件，其内容格式如下，写一个程序，判断该文件中是否存在"alex", 如果没有，则将字符串"alex"添加到该文件末尾，否则提示用户该用户已存在；
pizza alex egon
# 5，有名为username.txt的文件，其内容格式如下，写一个程序，
# 判断该文件中是否存在"alex", 如果没有，
# 则将字符串"alex"添加到该文件末尾，否则提示用户该用户已存在；
with open(‘username.txt‘,‘r+‘,encoding=‘utf-8‘) as f:
str1 = ‘alexx‘
i = f.read()
print(i)
if str1 in i:
print("the user already exist in")
else:
f.write(‘
alexx‘)
6，有名为user_info.txt的文件，其内容格式如下，写一个程序，删除id为100003的行；
pizza,100001 alex, 100002 egon, 100003
# 6，有名为user_info.txt的文件，其内容格式如下，
# 写一个程序，删除id为100003的行；
import os
a = ‘user_info.txt‘
b = ‘user_info1.txt‘
with open(a,‘r‘,encoding=‘utf-8‘) as f:
with open(b, ‘w‘, encoding=‘utf-8‘) as f2:
for i in f:
if ‘100003‘ in i:
pass
else:
f2.write(i)
os.replace(b,a)
7，有名为user_info.txt的文件，其内容格式如下，写一个程序，将id为100002的用户名修改为alex li；
pizza,100001 alex, 100002 egon, 100003
# 7，有名为user_info.txt的文件，其内容格式如下，写一个程序，
# 将id为100002的用户名修改为alex li；
file = ‘user_info.txt‘
old_str = ‘100002‘
new_str = ‘alex, 100002‘
file_data=‘‘
with open(file,‘r‘,encoding=‘utf-8‘) as f1:
for line in f1:
if old_str in line:
line =new_str
file_data +=line
with open(file,‘w‘,encoding=‘utf-8‘) as f1:
f1.write(file_data)
8，什么是装饰器？，写一个计算每个程序执行时间的装饰器；
装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能， 同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。 这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下， 提供了额外的功能。
8，写一个计算每个程序执行时间的装饰器；
import time
def timer(func):
def wrapper(*args,**kwargs):
start_time = time.time()
func(*args)
stop_time = time.time()
d_time = stop_time-start_time
print(d_time)
return wrapper
@timer
def sayhi():
print("hello word")
sayhi()
9，lambda是什么？请说说你曾在什么场景下使用lambda？
lambda函数就是可以接受任意多个参数(包括可选参数)并且返回单个表达式值得函数 好处： 1.lambda函数比较轻便，即用即扔，适合完成只在一处使用的简单功能 2.匿名函数，一般用来给filter，map这样的函数式编程服务 3.作为回调函数，传递给某些应用，比如消息处理
10，请分别介绍文件操作中不同文件之间打开方式的区别
| 模式 | 含义 |
| r | 文本只读模式 |
| rb | 二进制模式 这种方法是用来传输或存储，不给人看的 |
| r+ | 读写模式，只要有r，那么文件必须存在 |
| rb+ | 二进制读写模式 |
| w | 只写模式，不能读，用w模式打开一个已经存在的文件，如果有内容会清空，重新写 |
| wb | 以二进制方式打开，只能写文件，如果不存在，则创建 |
| w+ | 读写模式，先读后写，只要有w，会清空原来的文件内容 |
| wb+ | 二进制写读模式 |
| a | 追加模式，也能写，在文件的末尾添加内容 |
| ab | 二进制追加模式 |
| a+ | 追加模式，如果文件不存在，则创建文件，如果存在，则在末尾追加 |
| ab+ | 追读写二进制模式，从文件顶部读取文件，从文件底部添加内容，不存在则创建 |
11，简述普通参数，指定参数，默认参数，动态参数的区别
普通参数：以正确的顺序传入函数，调用时数量必须和声明的一样
指定参数：参数和函数调用关系密切，函数调用使用关键字参数来确定传入的参数值，参数允许函数调用时参数的顺序和声明时不一致
默认参数：函数进行调用时，如果没有新的参数传入则默认的情况下，就调用默认参数
动态参数：个别函数能处理比当初声明时更多的参数，这些参数就动态参数
12，写函数，计算传入的字符串中数字，字母，空格，以及其他的个数
def func(s):
al_num =0
space_num = 0
digit_num = 0
others_num = 0
for i in s:
if i.isdigit():
digit_num +=1
elif i.isspace():
space_num +=1
elif i.isalpha():
al_num +=1
else:
others_num +=1
return (al_num,space_num,digit_num,others_num)
result = func("asdsadjlk1212jdjakdk2 d d d d323233223下")
print(result)
result = func(" d d d d323233223下")
print(result)
13，写函数，判断用户传入的对象（字符串，列表，元组）长度是否大于5
def func(s,lis,tup):
zifuchuan = len(s)
liebiao = len(lis)
yuanzu = len(tup)
if zifuchuan>5:
print("大于5")
else:
print("小于5")
if liebiao >5:
print("大于5")
else:
print("小于5")
if yuanzu >5:
print("大于5")
else:
print("小于5")
return (zifuchuan,liebiao,yuanzu)
func(‘dadadad‘,‘[1,2,3]‘,{1,2,3})
14，写函数监测用户传入的对象（字符，列表，元组）的每一个元素是否有空内容
def func(n):
for i in a:
i = str(i)
if ‘‘ in i:
return (‘空格： ‘,i)
else:
return (‘没空格‘)
a = (‘dasdsd dasd‘,‘ds‘)
res = func(a)
print(res)
15，写函数，检查传入列表的长度，如果大于2，那么仅仅保留前两个长度的内容，并将新内容返回给调用者
def func(li):
len_li = len(li)
if len_li>2:
print("列表长度大于2")
new_li = li[0:2]
return (new_li)
res = func([12,12,45,78,32,12])
print(res)
16，写函数，检查获取传入列表或元组的所有奇数位索引对应的元素，并将其作为新列表返回给调用者
def func(li,tup):
li = []
tup = []
for i in range(len(li)):
if i %2 ==1:
li.append(li[i])
print(li)
for j in range(len(tup)):
if j %2 ==1:
tup.append(tup[j])
print(tup)
return (li,tup)
res = func([1,2,3,4,5,6,7,8,9],(1,2,3,11,21,4,5,6,7))
print(res)
17，写函数，检查传入字典的每一个value的长度，如果大于2，那么仅仅保存前两个长度的内容，并将新内容返回给调用者
def fun1(n):
for i,m in n.items():
m = str(m)
if len(m) > 2:
n[i] = m[0:2]
print(n)
dic = {‘name‘:‘fanfan‘,‘age‘:2,‘sex‘:‘boy‘}
fun1(dic)
18，写函数，计算传入字符串中的【数字】、【字母】、【空格】和【其他】的个数
# 18，写函数，计算传入字符串中的【数字】、【字母】、【空格】和【其他】的个数
def func(strr):
digit_number = 0
space_number = 0
alpha_number = 0
else_number = 0
for i in strr:
if i.isdigit():
digit_number +=1
elif i.isspace():
space_number +=1
elif i.isalpha():
alpha_number +=1
else:
else_number +=1
return ("数字，空格，字母，其他内容分别有：",(digit_number,space_number,alpha_number,else_number))
res = func(‘sda!@#$%^&1234567dfghj da da ‘)
print(res)
# (‘数字，空格，字母，其他内容分别有：‘, (7, 3, 12, 7))
以上是关于python函数编程闯关总结的主要内容，如果未能解决你的问题，请参考以下文章