文件处理相关
1，编码问题
（1）请问python2与python3中的默认编码是什么？
|
1 2 |
|
（2）为什么会出现中文乱码，你能举例说明乱码的情况有哪几种？
|
1 2 3 4 5 6 7 8 9 |
|
（3）如何进行编码转换？
|
1 2 3 4 5 6 7 8 9 10 11 12 |
|
（4）#_*_coding:utf-8_*_ 的作用是什么？
|
1 |
|
（5）解释python2.x bytes与python3.x bytes的区别
|
1 2 3 |
|
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
|
2，文件处理
（1） r和rb的区别是什么？
|
1 2 3 4 5 |
|
（2）解释一下下面三个参数的作用分别是什么？
|
1 |
|
|
1 2 3 4 5 6 |
|
（3） w和wb的区别是什么？
|
1 2 3 4 5 |
|
（4）a和ab的区别是什么？
|
1 2 3 4 5 |
|
（5）readline和readlines的区别
|
1 2 3 |
|
（6）全局替换程序：
写一个脚本，允许用户按以下方式执行时，即可以对指定文件内容进行全局替换
|
1 |
|
替换完毕后打印替换了多少处内容
（7）模拟登陆
- 用户输入帐号密码进行登陆
- 用户信息保存在文件内
- 用户密码输入错误三次后锁定用户，下次再登录，检测到是这个用户也登录不了
函数基础
1，写函数，计算传入数字参数的和。（动态传参）
|
1 2 3 4 5 6 7 8 9 10 11 12 |
|
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‘)
修改前的文件内容：
|
1 |
|
修改后的文件内容：
|
1 |
|
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(‘[email protected]#$%^&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’:最小值}
|
1 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？
|
1 2 3 |
|
3，通过生成器写一个日志调用方法， 支持以下功能
- 根据指令向屏幕输出日志
- 根据指令向文件输出日志
- 根据指令同时向文件&屏幕输出日志
- 以上日志格式如下
|
1 2 3 |
|
代码结构如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
|
内置函数
1，用map来处理字符串列表,把列表中所有人都变成sb,比方alex_sb
|
1 |
|
|
1 2 3 |
|
注意：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函数处理数字列表，将列表中所有的偶数筛选出来
|
1 |
|
|
1 2 3 4 5 6 7 8 9 10 11 12 |
|
3，如下，每个小字典的name对应股票名字，shares对应多少股，price对应股票的价格
|
1 2 3 4 5 6 7 8 |
|
计算购买每支股票的总价
用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]
|
1 2 3 4 |
|
其他练习
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函数的执行结果，并说明为什么：
|
1 2 3 4 5 6 7 8 9 10 |
|
如果函数收到的是一个不可变对象（比如数字、字符或者元组）的引用，就不能直接修改原始对象，相当于通过“传值’来传递对象，此时如果想改变这些变量的值，可以将这些变量申明为全局变量。
3，有列表 li = [‘alex‘, ‘egon‘, ‘smith‘, ‘pizza‘, ‘alen‘], 请以列表中每个元素的第二个字母倒序排序；
4，有名为poetry.txt的文件，其内容如下，请删除第三行；
|
1 2 3 4 5 6 7 |
|
# 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"添加到该文件末尾，否则提示用户该用户已存在；
|
1 2 3 |
|
|
1 2 3 4 5 6 7 8 9 10 11 |
|
6，有名为user_info.txt的文件，其内容格式如下，写一个程序，删除id为100003的行；
|
1 2 3 |
|
# 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；
|
1 2 3 |
|
# 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，什么是装饰器？，写一个计算每个程序执行时间的装饰器；
|
1 2 3 4 |
|
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
|
9，lambda是什么？请说说你曾在什么场景下使用lambda？
|
1 2 3 4 5 |
|
10，请分别介绍文件操作中不同文件之间打开方式的区别
| 模式 | 含义 |
| r | 文本只读模式 |
| rb | 二进制模式 这种方法是用来传输或存储，不给人看的 |
| r+ | 读写模式，只要有r，那么文件必须存在 |
| rb+ | 二进制读写模式 |
| w | 只写模式，不能读，用w模式打开一个已经存在的文件，如果有内容会清空，重新写 |
| wb | 以二进制方式打开，只能写文件，如果不存在，则创建 |
| w+ | 读写模式，先读后写，只要有w，会清空原来的文件内容 |
| wb+ | 二进制写读模式 |
| a | 追加模式，也能写，在文件的末尾添加内容 |
| ab | 二进制追加模式 |
| a+ | 追加模式，如果文件不存在，则创建文件，如果存在，则在末尾追加 |
| ab+ | 追读写二进制模式，从文件顶部读取文件，从文件底部添加内容，不存在则创建 |
11，简述普通参数，指定参数，默认参数，动态参数的区别
|
1 2 3 4 5 |
|
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，那么仅仅保存前两个长度的内容，并将新内容返回给调用者
18，写函数，计算传入字符串中的【数字】、【字母】、【空格】和【其他】的个数
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
|
原文地址：https://www.cnblogs.com/bj-mr-li/p/9686089.html