函数编程
1. 编码问题
i.请说明python2与python3中的默认编码是什么？
python2 ASCII 码 python3 字符串为unicode，文件默认编码为utf-8
ii.为什么会出现中文乱码？你能列举出现乱码的情况有哪几种？
读取使用的编码和存储时使用的编码不一致造成的。
存储的时候是GBK，打开的时候是使用UTF-8编码，就会出现乱码
iii.如何进行编码转换？
h = "你好" print(h) print(type(h)) h1 = h.encode(encoding="utf-8") #将字符串编码成utf-8的bytes print(h1) print(type(h1)) h2 = h1.decode(encoding="utf-8").encode(encoding="gbk") print(h2) print(type(h2)) h3 = h2.decode(encoding="gbk") #将gbk编码的bytes解码成字符串（unicode） print(h3) print(type(h3)) 你好 <class 'str'> b'\xe4\xbd\xa0\xe5\xa5\xbd' <class 'bytes'> b'\xc4\xe3\xba\xc3' <class 'bytes'> 你好 <class 'str'>
iv. #-*-coding:utf-8-*- 的作用是什么？
使用utf-8编码。
v. 解释py2 bytes vs py3 bytes的区别：
py2的 bytes和str 是一样的
py3的bytes就是二进制字节
2. 文件处理
i. r 和 rb 的区别是什么？
r 以只读的模式打开文件
rb 以只读的二进制模式打开文件
ii. 解释一下以下三个参数的分别作用
open(f_name,'r',encoding="utf-8")
f_name 是文件名，r 为读的模式， encoding="utf-8" 为打开文件编码
函数基础：
1. 写函数，计算传入数字参数的和。（动态传参）
def num_sum(*args):
total_sum = 0
for i in args:
total_sum += i
print(total_sum)
num_sum(2,3,4,-1,12)
2. 写函数，用户传入修改的文件名，与要修改的内容，执行函数，完成整个文件的批量修改操作
import os
def updata(file,old_contents,new_contents):
with open(file,"r",encoding="utf-8") as f ,open("tmp","w",encoding="utf-8") as f1:
for line in f:
line = line.replace(old_contents,new_contents)
f1.write(line)
os.remove(file)
os.rename("tmp",file)
updata("file.txt","hello","hi")
3. 写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容。
def isnull(arg):
for i in arg:
if str(i).isspace():
print("有空白字符，空格 或 制表符 或 换行")
isnull(("hh","gg"," ","dd"))
4. 写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
def my_dic(*args,**kwargs):
for i in kwargs:
if len(kwargs[i]) > 2:
print(len(kwargs[i]))
kwargs[i] = kwargs[i][:2]
return kwargs
dic = {"k1": "v1v1", "k2": [11,22,33,44]}
print(my_dic(**dic))
5. 解释闭包的概念。
在一些语言中，在函数中可以（嵌套）定义另一个函数时，如果内部的函数引用了外部的函数的变量，则可能产生闭包，就是当某个函数被当成对象返回时，夹带了外部变量，就形成了一个闭包。
函数进阶：
1. 写函数，返回一个扑克牌列表，里面有52项，每一项是一个元组 例如：[(‘红心’，2),(‘草花’，2), …(‘黑桃A’)]
def poker():
type_list = ("黑桃","红桃","方块","梅花")
num_list = (1,2,3,4,5,6,7,8,9,10,"J","Q","K")
poker_list = []
for i in type_list:
for j in num_list:
poker_list.append((i,j))
print(poker_list)
poker()
2. 写函数，传入n个数，返回字典{‘max’:最大值,’min’:最小值}
例如:min_max(2,5,7,8,4)
返回:{‘max’:8,’min’:2}
def min_max(*args):
max = args[0]
min = args[0]
for i in args:
if i >max:
max = i
if i< min:
min = i
return {"max":max, "min":min}
print(min_max(100,-6,2,3,6,98))
3. 写函数，专门计算图形的面积
其中嵌套函数，计算圆的面积，正方形的面积和长方形的面积
调用函数area(‘圆形’,圆半径) 返回圆的面积
调用函数area(‘正方形’,边长) 返回正方形的面积
调用函数area(‘长方形’,长，宽) 返回长方形的面积
def area():
def 计算长方形面积():
pass
def 计算正方形面积():
pass
def 计算圆形面积():
pass
def area(shape,*args): def rectangular(*args): area_total = args[0]*args[1] print(area_total) def square(*args): area_total = args[0] * args[0] print(area_total) def circular(*args): area_total = 3.14* args[0] * args[0] print(area_total) if shape == "长方形": return rectangular(*args) elif shape == "正方形": return square(*args) elif shape == "圆形": return circular(*args) area("圆形",2)
4. 写函数，传入一个参数n，返回n的阶乘 例如:cal(7) 计算7*6*5*4*3*2*1
def cal(n):
total = 1
for i in range(1,n+1):
total *= i
print(total)
cal(7)
5. 编写装饰器，为多个函数加上认证的功能（用户的账号密码来源于文件），要求登录成功一次，后续的函数都无需再输入用户名和密码
import json
logged = False
global_user = ""
def auth(fun):
def inner(*args,**kwargs):
global logged
if logged == False:
user = {
"zhangsan": ["zhangsan666",3,False],
"lisi": ["lisi666",0,True],
"wangwu": ["wangwu666",0,True]
} #用户名：[密码，密码输错次数，False锁定用户]
while True:
name = input("请输入你的姓名：").strip()
try:
with open("lockedname.txt","r+",encoding="utf-8") as f:
user = json.load(f) #若是有lockedname.txt文件，则user重新赋值
with open("expenses_record.txt", "r+", encoding="utf-8") as f2:
record_info = json.load(f2) # 若是有lockedname.txt文件，则user重新赋值
except Exception as err:
pass
if name not in user:
print("用户名不存在，请重新输入")
continue
elif user[name][2] == False:
print("用户已经被锁定，请联系管理员")
continue
elif record_info[name]["frozen"] == True:
print("账号已经被冻结，请联系管理员")
continue
elif name in user:
passwd = input("请输入你的密码：").strip()
if passwd == user[name][0]: # 判断用户名密码
print("欢迎 %s 同学"%(name))
user[name][1] = 0
with open("lockedname.txt", "w", encoding="utf-8") as f:
json.dump(user, f)
logged = True
global global_user
global_user = name
result = fun(*args,**kwargs)
return (0, name)
else:
user[name][1] += 1 # 同一个用户名输错密码加一
print("密码错误")
if user[name][1] >= 3:
print("用户账号已被锁定")
user[name][2] = False
with open("lockedname.txt", "w", encoding="utf-8") as f:
json.dump(user, f)
else:
result = fun(*args, **kwargs)
return inner
@auth
def tixian(name, cash_amount):
pass
@auth
def zhuanzhuang():
pass
生成器和迭代器
1. 生成器和迭代器的区别？
生成器是迭代器的一种，能做所有迭代器的事，而且因为自动创建了 iter()和 next()方法，生成器简洁，高效。使用生成器节省内存。
2. 生成器有几种方式获取value？
next()
for 循环
3. 通过生成器写一个日志调用方法，支持以下功能
根据指令向屏幕输出日志
根据指令向文件输出日志
根据指令同时向文件&屏幕输出日志
日志格式如下
2017-10-19 22:07:38 [1] test log db backup 3
2017-10-19 22:07:40 [2] user alex login success
代码结构如下
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')
import logging
def logger(filename,channel='terminal'):
"""
日志方法
:param filename: log filename
:param channel: 输出目的地，屏幕(҅terminal)，文件(file)，屏幕+文件(both)
:return:
"""
log = logging.getLogger()
log.setLevel(logging.DEBUG)
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
fh = logging.FileHandler(filename, encoding="utf-8")
fh.setLevel(logging.DEBUG)
formatter = logging.Formatter(
fmt="%(asctime)s %(message)s",
datefmt="%Y/%m/%d %X",
)
ch.setFormatter(formatter)
fh.setFormatter(formatter)
count = 0
while True:
count += 1
mg = yield "ok"+str(count)
# mg = yield
meg = "[%s] %s"%(count,mg)
if channel == 'terminal':
log.addHandler(ch)
log.info(meg)
log.removeHandler(ch)
elif channel == 'file':
log.addHandler(fh)
log.info(meg)
log.removeHandler(fh)
elif channel == 'both':
log.addHandler(ch)
log.addHandler(fh)
log.info(meg)
log.removeHandler(ch)
log.removeHandler(fh)
ll = logger("text.log",channel='both')
print(ll.__next__())
print(ll.send('user alex login success'))
ll.send('user lili login success')
ll.send('user nana login success')
内置函数
1，用map来处理字符串列表,把列表中所有人都变成sb,比方alex_sb
map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。
def f(arg):
arg = arg+"_sh"
return arg
lis = ["alex","lili","wangwu"]
lis_new = map(f,lis)
print(lis_new.__next__())
print(lis_new.__next__())
print(lis_new.__next__())
2，用filter函数处理数字列表，将列表中所有的偶数筛选出来
filter()用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
num = [1,3,5,6,7,8]def f1(n):
if n%2 == 0:
return True
else:
return False
num = [1,3,5,6,7,8]
num_new = filter(f1,num)
print(num_new.__next__())
print(num_new.__next__())
num_new2 = filter(lambda x:x%2 == 0,[1,3,5,6,7,8])
print(num_new2.__next__())
print(num_new2.__next__())
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}]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 f2(i):
if i['price'] > 100:
return True
portfolio_new = filter(f2,portfolio)
# print(portfolio_new.__next__())
# print(portfolio_new.__next__())
for i in portfolio_new:
print(i)
