路飞学城Python-Day12(practise)

# 函数基础
# 1.写函数，计算传入数字参数的和(动态传参)
# def sum_num(x,y):
#     return x+y
# print(sum_num(1,2))
# 2.写函数，用户传入修改的文件名，与要修改的内容，执行函数，完成整个文件的批量修改操作
# def file(filename,parts):
#     f = open(filename,'w+',encoding='utf-8')
#     f.write(parts)
#     f.close()
# file('staff',"abc")
# 3.写函数，检查用户传入的对象（字符串、列表、元祖）的每一个元素是否含有空内容
# def check(obj):
#     for i in obj:
#         if len(i.split(' ')) >= 2:
#             print('%s内部元素%s有空内容'%(obj,i))
# check(['1 ','2'])
#4.写函数，检查传入字典的每一个value的长度，如果大于2，那么保留前两个长度的内容，并将新内容返回给调用者
# dic = {'k1':'v1v1','k2':[11,22,33,44]}
# # PS:字典中的value只能是字符串或列表
# for k,v in dic.items():
#     if len(v)>2:
#         dic[k] = v[0:2]
# print(dic)
# 5.解释闭包的概念
# 闭包：关于闭包，即函数定义和函数表达式位于另一个函数的函数体内(嵌套函数)。而且，这些内部函数可以访问它们所在的外部函数中声明的所有局部变量
# 参数。当其中一个这样的内部函数在包含它们的外部函数之外被调用时，就会形成闭包。也就是说，内部函数会在外部函数返回后被执行。
# 而当这个内部函数执行时，它仍然必须访问其外部函数的局部变量、参数以及其他内部函数。这些局部变量、参数和函数声明(最初时)的值是外部函数返回时的值
# 但是也会受外部函数的影响
# -------------------------------------------------------------------------------------------------------------------------------
#写函数，检查传入字典的每一个value的长度，如果大于2，那么保留前两个长度的内容，并将新内容返回给调用者
# dic = {'k1':'v1v1','k2':[11,22,33,44]}
# # PS:字典中的value只能是字符串或列表
# for k,v in dic.items():
#     if len(v)>2:
#         dic[k] = v[0:2]
# print(dic)
# 5.解释闭包的概念
# 闭包：关于闭包，即函数定义和函数表达式位于另一个函数的函数体内(嵌套函数)。而且，这些内部函数可以访问它们所在的外部函数中声明的所有局部变量
# 参数。当其中一个这样的内部函数在包含它们的外部函数之外被调用时，就会形成闭包。也就是说，内部函数会在外部函数返回后被执行。
# 而当这个内部函数执行时，它仍然必须访问其外部函数的局部变量、参数以及其他内部函数。这些局部变量、参数和函数声明(最初时)的值是外部函数返回时的值
# 但是也会受外部函数的影响
# -------------------------------------------------------------------------------------------------------------------------------
# 函数进阶
# 1.写函数，返回一个扑克牌列表，里面有52项，每一项是一个元祖i，例如:[('红心',2),('草花',2),...('黑桃A')]
# def poke ():
#     poke_1 = ['红心','草花','黑桃','方片']
#     poke_num = [2,3,4,5,6,7,8,9,10]
#     poke_dig = ['A','K','J','Q']
#     poke_special = ['JOKER1','JOKER2']
#     poke_l1 = []
#     for i in poke_1:
#         for l in poke_num:
#                 poke_tuple =(i,l)
#                 poke_l1.append(poke_tuple)
#     for j in poke_1:
#         for k in poke_dig:
#             poke_tuple_2 = tuple((j+k).strip().split(','))
#             poke_l1.append(poke_tuple_2)
#     for m in poke_special:
#         poke_l1.append(tuple(m.strip().split(',')))
#     print(poke_l1)
# poke()
# -------------Low版-------------------------
# 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())
# -------------高级版-但是有bug('黑桃', 'A')!=('黑桃A')-----------
# 2.写函数，传入n个数，返回字典{'max':最大值,'min':最小值}
# def foo(*args):
#     dic = {'max':None,'min': None}
#     dic['max'] = max(args)
#     dic['min'] = min(args)
#     return dic
# print(foo(1,2,3,5,7,3,2,10))
# 3.写函数，专门计算图形的面积
# 其中嵌套函数，计算圆的面积，正方形的面积和长方形的面积
# 调用函数area(‘圆形’,圆半径) 返回圆的面积
# 调用函数area(‘正方形’,边长) 返回正方形的面积
# 调用函数area(‘长方形’,长，宽) 返回长方形的面积
# def area():
#     import math
#     def round_area():
#         rad = int(input('请输入半径>>'))
#         area_round = math.pi*rad*rad
#         print('圆形面积是'+str(area_round))
#     def square_area():
#         side = int(input('请输入边长>>'))
#         area_square = side*side
#         print('正方形的面积是'+str(area_square))
#     def rectangle_area():
#         length = int(input('请输入长'))
#         width = int(input('请输入宽'))
#         area_rectangle = length*width
#         print('长方形的面积是'+str(area_rectangle))
#     area_choice = input('请选择需要计算的图形\n1.圆形\n2.正方形\n3.长方形')
#     if area_choice == '1':
#         round_area()
#     elif area_choice =='2':
#         square_area()
#     elif area_choice =='3':
#         rectangle_area()
#     else:
#         print('错误的命令！')
# area()
# 4.写函数，传入一个参数n，返回n的阶乘
# def cal(x):
#     sum = 1
#     for i in range(1,x+1):
#         sum = sum*i
#     print(sum)
# cal(10)
# 5.编写装饰器，为多个函数加上认证功能（用户的账号密码来源于文件），要求登录成功一次，后续的函数都无需再输入用户名和密码
# def wapper(func):
#     def inner(*args,**kwargs):
#         import json
#         status = False
#         if status ==True:
#             res = func(*args, **kwargs)
#             return res
#         else:
#             i = 0
#             while i<3:
#                 with open('user_info', 'r', encoding='utf-8') as f:
#                     info = json.load(f)
#                     user = [i for i in info]
#                     username = input('请输入用户名>>>').strip()
#                     password = input('请输入密码>>>').strip()
#                     if username in user and info[username] ==password:
#                         print('登陆成功')
#                         status = True
#                         res = func(*args, **kwargs)
#                         return res
#                     else:
#                         print('登录失败，请重试')
#                         i += 1
#     return inner
# @wapper
# def login():
#     print('欢迎登陆！')
# @wapper
# def logout():
#     print('登出！')
#
# login()
# logout()
# ---------------------------------------
# 生成器和迭代器
# 1.生成器和迭代器的区别？
# 生成器都是迭代器，都是列表、字典、字符串虽然都是迭代对象，但是都不是迭代器，因为不能使用next()方法，但是可以使用iter()函数将它们变成迭代器
# 迭代器就是一个数据流，生成迭代器的时候不需要规定终止点，没有终止也不需要终止条件，这样的就表示为数据流。
# 这是因为Python的Iterator对象表示的是一个数据流，iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出错误，可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个序列，所以Iterator的计算是惰性的，只有在需要返回下一个数据时才回去计算。
# 总结：
# 凡是可以作用for循环的对象都是Iterator类型；
# 生成器一定是迭代器，迭代器不一定是生成器（可以自己写对象）
# 2.生成器有几种方式获取value？
# 1.for循环
# 2.next()
# 3.__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:
#     """
# pass
#
# #     # 调用
# #
# #
# # log_obj = logger(filename="web.log", channel='both')
# # log_obj.__next__()
# # log_obj.send('user alex login success')

import datetime
count = 0


def logger(filename, channel):
    global count
    while True:
        count += 1  # 日志方法第几次调用
        mes = yield  # 接收消息
        info = '%s [%s] %s'% (datetime.datetime.now(), count, mes)

        def file():  # 输出到文件
            with open(filename, "a", encoding="utf-8") as f:
                f.write("\n%s" % info)

        def terminal():  # 输出到终端
            print(info)

        if channel == "file":  # 输出到文件
            file()
        elif channel == "terminal":  # 输出到终端
            terminal()
        elif channel == "both":  # 都输出
            file()
            terminal()
log_obj = logger(filename="test_file", channel='both')
log_obj.__next__()
log_obj.send('user alex login success')  # 发送消息
log_obj.send('test log db backup 3')

# 内置函数
# 1，用map来处理字符串列表,把列表中所有人都变成sb,比方alex_sb
# name=['alex','wupeiqi','yuanhao','nezha']
# def change(x):
#     return x+'_sb'
# res = map(change,name)
# print(list(res))

# 2，用filter函数处理数字列表，将列表中所有的偶数筛选出来
# num = [1,3,5,6,7,8]
# def func(x):
#     if x % 2 == 0:
#         return x
# print(list(filter(func,num)))
# 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的股票有哪些
# def sum():
#     for i in portfolio:
#         print(i['name'],i['shares']*i['price'])
# f = filter(lambda d:d['price']>=100,portfolio)
# print(list(f))