#写函数，计算传入数字参数的和。（动态传参）
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、写函数，用户传入修改的文件名，与要修改的内容，执行函数，完成整个文件的批量修改操作
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

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‘,[],())
# 字符串里面没有空内容
# 列表有空内容
# 元祖有空内容

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]]

    关于闭包，即函数定义和函数表达式位于另一个函数的函数体内（嵌套函数）。而且这些内部函数可以访问他们所在的外部函数中声明的所有局部变量，参数。当其中一个这样的内部函数在包含他们的外部函数之外被调用时候，就形成了闭包。
也就是说，内部函数会在外部函数返回后被执行。而当这个内部函数执行的时候，它仍然必需访问其外部函数的局部变量，参数以及其他内部函数，这些局部变量，参数声明（最初时）的值是外部函数返回时候的值，但也会受到内部函数的影响。
    闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域

# 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))

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‘)]

例如: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}

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)

例如: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，编写装饰器，为多个函数加上认证的功能（用户的账号密码来源于文件），
# 要求登录成功一次，后续的函数都无需再输入用户名和密码
 
 
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()

对于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即可。

两种方式获取：
    for 循环
    next 获取

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‘)

name=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,‘nezha‘]

map()函数
map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把
函数 f 依次作用在 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‘]

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]

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}
]

# 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”开头的元素的首字母改为大写字母；
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)

num = 20
 
   def show_num(x=num):
       print(x)
 
   show_num()
 
   num = 30
 
   show_num()

li = [‘alex‘, ‘egon‘, ‘smith‘, ‘pizza‘, ‘alen‘]
print(list(sorted(li,key=lambda x :x[1],reverse=True)))

昔人已乘黄鹤去，此地空余黄鹤楼。
 
黄鹤一去不复返，白云千载空悠悠。
 
晴川历历汉阳树，芳草萋萋鹦鹉洲。
 
日暮乡关何处是？烟波江上使人愁。

# 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)

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(‘\nalexx‘)

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)

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)

　　装饰器模式（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()

lambda函数就是可以接受任意多个参数(包括可选参数)并且返回单个表达式值得函数
　　好处：
　　　　1.lambda函数比较轻便，即用即扔，适合完成只在一处使用的简单功能
　　　　2.匿名函数，一般用来给filter，map这样的函数式编程服务
　　　　3.作为回调函数，传递给某些应用，比如消息处理

普通参数：以正确的顺序传入函数，调用时数量必须和声明的一样

指定参数：参数和函数调用关系密切，函数调用使用关键字参数来确定传入的参数值，参数允许函数调用时参数的顺序和声明时不一致

默认参数：函数进行调用时，如果没有新的参数传入则默认的情况下，就调用默认参数

动态参数：个别函数能处理比当初声明时更多的参数，这些参数就动态参数

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)

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})

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)

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)

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)

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，写函数，计算传入字符串中的【数字】、【字母】、【空格】和【其他】的个数
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))