文件处理
1、编码问题
请说明python2 与python3中的默认编码是什么?
答案: py2默认ASCII码,py3默认的utf8
2、为什么会出现中文乱码?你能列举出现乱码的情况有哪几种?
答案:
coding:utf-8 #.py文件是什么编码就需要告诉python用什么编码去读取这个.py文件。
sys.stdout.encoding,默认就是locale的编码,print会用sys.stdout.encoding去encode()成字节流,交给terminal显示。所以locale需要与terminal一致,才能正确print打印出中文。
sys.setdefaultencoding(‘utf8’),用于指定str.encode() str.decode()的默认编码,默认是ascii。
以下几种(local 为软件运行时的语言环境):
终端为UTF-8,locale为zh_CN.GBK
终端为UTF-8,locale为zh_CN.UTF-8
终端为GBK,locale为zh_CN.GBK
终端为GBK,locale为zh_CN.UTF-8
3、如何进行编码转换?
答案: 字符串在python内部中是采用unicode的编码方式,所以其他语言先decode转换成unicode编码,再encode转换成utf8编码。
4、#-*-coding:utf-8-*- 的作用是什么?
答案: 编码声明
5、解释py2 bytes vs py3 bytes的区别
答案
Python 2 将 strings 处理为原生的 bytes 类型,而不是 unicode(python2 str == bytes),
Python 3 所有的 strings 均是 unicode 类型(python3 中需要通过 unicode )
string -> encode -> bytes
bytes -> decode -> string
6、文件处理:
1、r和rb的区别是什么?
答案:r 读模式 rb 二进制读
2、解释一下以下三个参数的分别作用
open(f_name,'r',encoding="utf-8")
答案:f_name :文件名 r : 模式 encoding : 编码方式
函数基础:
1、写函数,计算传入数字参数的和。(动态传参)
答案
def sum(*args):
sum = 0
for i in args:
sum += i
print(sum)
sum(10,3,2,1,4,5,6,7,8,9)
#answer
def func_sum(x, y):
return x + y
print(func_sum(2,3))
2、写函数,用户传入修改的文件名,与要修改的内容,执行函数,完成整个文件的批量修改操作
答案
def func(name,msg,n_msg): #占内存
f = open(name,"r+",encoding="utf-8")
data = f.read().split("\n")
li = []
for i in data:
if msg in i:
i = i.replace(msg,n_msg)
li.append(i)
f.truncate(0)
n_data = "\n".join(li)
f.write(n_data)
func("123","天安门","故宫")
def func(name,msg,n_msg): #占硬盘
import os
f = open(name,"r",encoding="utf-8")
f2 = open(name+"new","w",encoding = "utf-8")
for line in f:
if msg in line:
line = line.replace(msg,n_msg)
f2.write(line)
f.close()
f2.close()
os.replace(name+"new",name)
func("123","故宫","天安门")
3、 写函数,检查用户传入的对象(字符串、列表、元组)的每一个元素是否含有空内容。
答案
def check(obj):
count = 0
for i in obj:
if i == " ":
count += 1
print("含%s有空格"%count)
4、写函数,检查传入字典的每一个value的长度,如果大于2,那么仅保留前两个长度的内容,并将新内容返回给调用者。
dic = {"k1": "v1v1", "k2": [11,22,33,44]}
PS:字典中的value只能是字符串或列表
答案
dic = {"k1": "v1v1", "k2": [11,22,33,44]}
def change(dictionary):
for i in dictionary:
if len(dictionary[i]) > 2:
dictionary[i] = dictionary[i][:2]
print(dictionary)
# answer
def func(dic): # i为所传字典
for k, v in dic.items():
if len(v) > 2:
dic[k] = v[:2]
else:
continue
return dic
print(func({
"k1": "v1v1", "k2": [11,22,33,44]}))
5、 解释闭包的概念
# 答案
闭包(closure)是函数式编程的重要的语法结构。函数式编程是一种编程范式 (而面向过程编程和面向对象编程也都是编程范式)。
在面向过程编程中,我们见到过函数(function);在面向对象编程中,我们见过对象(object)。函数和对象的根本目的是以某种逻辑方式组织代码,并提高代码的可重复使用性(reusability)。
闭包也是一种组织代码的结构,它同样提高了代码的可重复使用性。
函数(外)中又定义了一个函数(内),并且内函数可以引用外函数的参数和局部变量。当外函数返回内函数时,相关参数和变量都保存在返回的函数中。
定义:如果一个内部函数里对外部函数(不是在全局作用域)的变量进行引用,内部函数就被认为是闭包。
函数进阶:
1、写函数,返回一个扑克牌列表,里面有52项,每一项是一个元组
例如:[(‘红心’,2),(‘草花’,2), …(‘黑桃A’)]
答案:
def poker():
num = []
for i in range(2,11):
num.append(i)
num.insert(0,"A")
num.extend(["J","Q","K"])
lis = ['红心', '草花', '方块', '黑桃']
cards = []
for i in lis:
for j in num:
cards.append((i,j))
return cards
print(poker())
# answer
# 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
2、写函数,传入n个数,返回字典{‘max’:最大值,’min’:最小值}
例如:min_max(2,5,7,8,4) 返回:{‘max’:8,’min’:2}
答案
def min_max(*args):
min = args[0]
max = args[0]
for i in args:
if i <= min:
min = i
if i >= max:
max = i
dic = {"max":max,"min":min}
return dic
print(min_max(1,2,3,4,5))
# answer
def max_min(*args):
the_max = args[0]
the_min = args[0]
for i in args:
if i > the_max:
the_max = i
if i < the_min:
the_min = i
return {'max': the_max, 'min': the_min}
print(max_min(2, 4, 6, 48, -16, 999, 486, ))
3、写函数,专门计算图形的面积
其中嵌套函数,计算圆的面积,正方形的面积和长方形的面积
调用函数area(‘圆形’,圆半径) 返回圆的面积
调用函数area(‘正方形’,边长) 返回正方形的面积
调用函数area(‘长方形’,长,宽) 返回长方形的面积
def area(): def 计算长方形面积(): pass def 计算正方形面积(): pass def 计算圆形面积(): pass
答案
def area(name,*args):
def circle():
r = int(input("请输入半径:"))
return("圆形面积为:%s"%(r*r*3.14))
def rectangle():
a = int(input("请输入边长:"))
b = int(input("请输入另一边长:"))
return("长方形面积为:%s"%(a*b))
def cube():
l = int(input("请输入边长:"))
return("正方形面积为:%s"%(l*l))
if name == "circle":
return circle()
elif name == "rectangle":
return rectangle()
elif name == "cube":
return cube()
chioce = input("choice:")
print(area(chioce))
# answer
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))
4、写函数,传入一个参数n,返回n的阶乘
例如:cal(7)
计算7*6*5*4*3*2*1
答案
def inter(num,pro):
if num == 1:
return pro
return inter(num-1,num*pro)
def cal(n):
return inter(n,1)
print(cal(5))
# answer
def cal(n):
res= 1
for i in range(n,0,-1):
# print(i)
res = res*i
print(res)
return res
print(cal(7))
9、编写装饰器,为多个函数加上认证的功能(用户的账号密码来源于文件),要求登录成功一次,后续的函数都无需再输入用户名和密码
答案
status = False
def confirm(func):
def inner():
f = open("3编写装饰器","r",encoding="utf-8")
msg = f.read()
msg = eval(msg)
global status
if not status:
name = input("input name:")
password = input("enter npassword:")
if name == msg["name"] and password == msg["password"]:
print("log in ...")
status = True
else:
func()
return inner
@confirm
def welcome():
print("welcome.....")
welcome()
welcome()
import time
flag = False
def login(name,passwd):
f = open("装饰器练习1","r",encoding="utf-8")
data = f.readlines()
for i in data:
i.strip()
msg = eval(i)
if name == msg["name"] and passwd == msg["password"]:
global flag
flag = True
def outer(func):
def timmer():
if not flag:
name = input("username:")
passw = input("password:")
login(name,passw)
if flag:
start = time.time()
func()
stop = time.time()
take = stop-start
print("time is %s" %take)
else:
print("wrong")
return timmer
@outer
def test1():
time.sleep(1)
print("test1")
@outer
def test2():
time.sleep(2)
print("test2")
@outer
def test3():
time.sleep(3)
print("test3")
test1()
test2()
test3()
# answer
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')
def terminal(count,msg):
import time
timmer = time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(time.time()))
print(timmer,"[%s]"%count,msg)
def file(filename,count,msg):
import time
timmer = time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(time.time()))
f = open(filename,"a",encoding="utf-8")
data =timmer,"[%s]"%count,msg
f.write(str(data))
f.close()
def logger(filename,channel):
count = 0
while True:
count += 1
msg = yield
if channel == "terminal":
terminal(count,msg)
elif channel == "file":
file(filename, count,msg)
elif channel == "both":
file(filename, count,msg)
terminal(count,msg)
yield
log_obj = logger(filename="web.log",channel='both')
log_obj.__next__()
log_obj.send('user alex login success')
log_obj.__next__()
log_obj.send('user login success')
内置函数
1、用map来处理字符串列表,把列表中所有人都变成sb,比方alex_sb
name=['alex','wupeiqi','yuanhao','nezha']
答案:
def a_name(str):
str = str + "_sb"
return str
name=['alex','wupeiqi','yuanhao','nezha']
last = list(map(a_name,name))
print(last)
map()函数
map()是 Python 内置的高阶函数,它接收一个函数 f 和一个 list,并通过把
函数 f 依次作用在 list 的每个元素上,得到一个新的 list 并返回。
注意:map()函数在不改变原有的list,而是返回一个新的list
代码:
name=['alex','wupeiqi','yuanhao','nezha']
def sb(x):
return x+'_sb'
res = map(sb,name)
print(list(res))
2、用filter函数处理数字列表,将列表中所有的偶数筛选出来
num = [1,3,5,6,7,8]
# answer
num = [1,3,5,6,7,8]
def func(x):
if x%2 == 0:
return True
ret = filter(func,num)
print(list(ret))
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}
]
a、计算购买每支股票的总价
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}
]
def t_p():
for i in portfolio:
total = i["shares"]*i["price"]
i["total"] = total
return property
t_p()
for i in portfolio:
print(i)
b、用filter过滤出,单价大于100的股票有哪些?
f = filter(lambda d: d['price'] >= 100, portfolio)
print(list(f))
4、请分别介绍文件操作中不同的打开方式之间的区别:
模式 | 含义 |
---|---|
r | 文本只读模式 |
rb | 二进制模式 这种方法是用来传输或存储,不给人看的 |
r+ | 读写模式,只要有r,那么文件必须存在 |
rb+ | 二进制读写模式 |
w | 只写模式,不能读,用w模式打开一个已经存在的文件,如果有内容会清空,重新写 |
wb | 以二进制方式打开,只能写文件,如果不存在,则创建 |
w+ | 读写模式,先读后写,只要有w,会清空原来的文件内容 |
wb+ | 二进制写读模式 |
a | 追加模式,也能写,在文件的末尾添加内容 |
ab | 二进制追加模式 |
a+ | 追加模式,如果文件不存在,则创建文件,如果存在,则在末尾追加 |
ab+ | 追读写二进制模式,从文件顶部读取文件,从文件底部添加内容,不存在则创建 |
5、有列表 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)
#or
for i in range(len(li)):
if li[i][0] == 'a':
li[i] = li[i].capitalize()
else:
continue
print(li)
li = ['alex', 'egon', 'smith', 'pizza', 'alen']
li_n = []
def func(li):
for i in li:
if i.startswith("a"):
i = i.capitalize()
li_n.append(i)
return li_n
print(func(li))
6、有如下程序, 请给出两次调用show_num
函数的执行结果,并说明为什么:
num = 20
def show_num(x=num):
print(x)
show_num()
num = 30
show_num()
答案:
20
20
如果函数收到的是一个不可变对象(比如数字、字符或者元组)的引用,就不能直接修改原始对象,相当于通过“传值’来传递对象,此时如果想改变这些变量的值,可以将这些变量申明为全局变量。
7、有列表 li = ['alex', 'egon', 'smith', 'pizza', 'alen'], 请以列表中每个元素的第二个字母倒序排序;
li = ['alex', 'egon', 'smith', 'pizza', 'alen']
print(sorted(li, key=lambda x: x[1], reverse=True))
8、有名为poetry.txt
的文件,其内容如下,请删除第三行;
昔人已乘黄鹤去,此地空余黄鹤楼。
黄鹤一去不复返,白云千载空悠悠。
晴川历历汉阳树,芳草萋萋鹦鹉洲。
日暮乡关何处是?烟波江上使人愁。
# answer
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)
# or
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)
f = open("poetry.txt","r+",encoding="utf-8")
data = f.read().split("\n")
del data[2]
f.truncate(0)
f.write("\n".join(data))
f.close()
9、有名为username.txt
的文件,其内容格式如下,写一个程序,判断该文件中是否存在"alex", 如果没有,则将字符串"alex"添加到该文件末尾,否则提示用户该用户已存在;
pizza
alex
egon
f_name = "username.txt"
f = open(f_name,"r",encoding="utf-8")
data = f.readlines()
f.close()
data = data.strip().split(",")
str = "alex"
for i in data:
if str in data:
print("该用户已存在")
else:
data.append(str)
f = open(f_name, "w", encoding="utf-8")
f.truncate()
data =" ".join(data)
f.write(data)
f.close()
# answer
with open('username.txt', 'r+', encoding='utf-8') as f:
str1 = 'alex'
i = f.read()
print(i)
if str1 in i:
print("the user already exist in")
else:
f.write('\nalex')
f = open("username.txt","r+")
data = f.read().split("\n")
if "alex" in data:
print("have")
else:
f.write("\nalex")
10、有名为user_info.txt的文件,其内容格式如下,写一个程序,删除id为100003的行;
pizza,100001
alex, 100002
egon, 100003
# answer
# 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)
f = open("user_info.txt","r+")
data = f.read().split("\n")
li = []
for i in data:
if "100003" not in i:
li.append(i)
else:
continue
f.truncate(0)
f.write("\n".join(li))
11、有名为user_info.txt的文件,其内容格式如下,写一个程序,将id为100002的用户名修改为alex li
;
pizza,100001
alex, 100002
egon, 100003
f = open("user_info.txt","r+")
data = f.read().split("\n")
li = []
for i in data:
if "100002" in i:
i = i.split(",")
i[0] = "alex li"
i=",".join(i)
print(type(i))
li.append(i)
f.truncate(0)
f.write("\n".join(li))
12、写一个计算每个程序执行时间的装饰器;
# import time
# def outer(func):
# def timmer():
# start = time.time()
# func()
# stop = time.time()
# take = stop-start
# print("time is %s" %take)
# return timmer
#
#
# @outer
# def test1():
# time.sleep(1)
# print("test1")
#
# @outer
# def test2():
# time.sleep(2)
# print("test2")
#
# @outer
# def test3():
# time.sleep(3)
# print("test3")
#
# test1()
# test2()
# test3()
13、lambda是什么?请说说你曾在什么场景下使用lambda?
答案:
lambda函数就是可以接受任意多个参数(包括可选参数)并且返回单个表达式值得函数
好处:
1.lambda函数比较轻便,即用即扔,适合完成只在一处使用的简单功能
2.匿名函数,一般用来给filter,map这样的函数式编程服务
3.作为回调函数,传递给某些应用,比如消息处理
14、题目:写一个摇骰子游戏,要求用户压大小,赔率一赔一。
要求:三个骰子,摇大小,每次打印摇骰子数。
import random
def roll_dice(numbers=3, points=None): #定义骰子,循环三次
if points is None:
points = []
print('----- 摇骰子 -----')
while numbers > 0:
point = random.randrange(1, 7)
# print('roll dice is {}'.format(point))
points.append(point)
numbers -= 1
return points
def roll_result(total): #定义大小,三个大或者一个小两个大。三个小或者两个小一个大
is_big = 11 <= total <= 18
is_small = 3 <= total <= 10
if is_big:
return "big"
elif is_small:
return "small"
def start_game():
money = 1000
while money > 0:
print('----- 游戏开始 -----')
choices = ['big', 'small']
your_choice = input("请下注, big or small")
your_bet = input("下注金额:")
if your_choice in choices:
if your_bet.isdigit():
points = roll_dice()
total = sum(points)
you_win = your_choice == roll_result(total)
if you_win:
print("骰子点数", points, total)
money += int(your_bet)
print("恭喜, 你赢了%s元, 你现在的本金%s 元" % (your_bet, money))
else:
print("骰子点数", points, total)
money -= int(your_bet)
print("很遗憾, 你输了%s元, 你现在的本金%s 元" % (your_bet, money))
else:
print('格式有误,请重新输入')
else:
print('格式有误,请重新输入')
else:
print("game over")
start_game()