文成小盆友python-num4 内置函数

一 .python 内置函数补充

  • chr()  -- 返回所给参数对应的 ASCII 对应的字符，与ord()相反
# -*- coding:utf-8 -*-
# Author:wencheng.zhao

a = chr(65)
print(a)

b = chr(66)
print(b)

##输出如下:
A
B

Process finished with exit code 0
  • ord --返回所给的值在ASCII中对应的数字，与chr()作用相反
# -*- coding:utf-8 -*-
# Author:wencheng.zhao

a = ord("A")
b = ord("B")
print(a)
print(b)
##显示如下：
65
66

Process finished with exit code 0

　ascii表对应如下：

　　　　　　ASCII:

　　应用如上两个内置函数编写一个自动生成验证码的小程序：

　　要求： 随机产生8为验证码

　　　　　 验证码包含数字和字母，代码实现如下

# -*- coding:utf-8 -*-
# Author:wencheng.zhao
import random

li = []   ##定义一个空列表用于存放结果

for i in range(8):       #每次生成一个字母or数字,生成8次
    r = random.randrange(0,8)   ##当r为此范围内的数字时就让次位置上的验证码为纯数字
    if r == 2 or r == 4:        ##随便等于 等于的值越多 产生纯数字的可能行就也越大
        num = random.randrange(0,10)   ##num为0-9的任意随机数字
        li.append(str(num))            ##将数字结果存如空列表中
    else:                              ##如果没有为纯数字的情况
        temp = random.randrange(65,91)  ##根据ascii表可得 65 - 90 为应为字母
        c = chr(temp)                   ##将得到的随机数字转换成对应的字母
        li.append(c)                    ##将结果存放到最终列表里

result = " ".join(li)                    #将结果排列

print(result)                           #打印结果

＃＃＃最终现实如下：

D 9 F 3 1 O X 4

Process finished with exit code 0
  • compile()    将source编译成代码或者对象，代码或者对象能够通过语句exec（）执行或者通过eval（）来求值
  • exec()         执行python的代码 －－ 执行完毕后无返回值。
  • eval()          执行python表达式 －－执行完毕后有返回值。对比如下：
code = "print(123)"
aa = compile(code,"<string>","exec")  ##编译

ss = exec(aa)  # 执行
print(ss)      #无返回值

num = "8*8"
bb = eval(num)
print(bb)      #有返回值,返回值为计算结果

##现实结果如下：
123
None
64

Process finished with exit code 0
  • dir()  --用来快速获取＊＊所提供的功能
a = dir(list)
print(a)
##显示结果如下：
[‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__delitem__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__gt__‘, ‘__hash__‘, ‘__iadd__‘, ‘__imul__‘, ‘__init__‘, ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__mul__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__reversed__‘, ‘__rmul__‘, ‘__setattr__‘, ‘__setitem__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘append‘, ‘clear‘, ‘copy‘, ‘count‘, ‘extend‘, ‘index‘, ‘insert‘, ‘pop‘, ‘remove‘, ‘reverse‘, ‘sort‘]

Process finished with exit code 0
  • help() --- 查看帮助 ，比较详细

help(list)

＃显示如下：
class list(object)
 |  list() -> new empty list
 |  list(iterable) -> new list initialized from iterable‘s items
 |
 |  Methods defined here:
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __contains__(self, key, /)
 |      Return key in self.
 |
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __iadd__(self, value, /)
 |      Implement self+=value.
 |
 |  __imul__(self, value, /)
 |      Implement self*=value.
 |
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __iter__(self, /)
 |      Implement iter(self).
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __len__(self, /)
 |      Return len(self).
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.n
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __reversed__(...)
 |      L.__reversed__() -- return a reverse iterator over the list
 |
 |  __rmul__(self, value, /)
 |      Return self*value.
 |
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |
 |  __sizeof__(...)
 |      L.__sizeof__() -- size of L in memory, in bytes
 |
 |  append(...)
 |      L.append(object) -> None -- append object to end
 |
 |  clear(...)
 |      L.clear() -> None -- remove all items from L
 |
 |  copy(...)
 |      L.copy() -> list -- a shallow copy of L
 |
 |  count(...)
 |      L.count(value) -> integer -- return number of occurrences of value
 |
 |  extend(...)
 |      L.extend(iterable) -> None -- extend list by appending elements from the iterable
 |
 |  index(...)
 |      L.index(value, [start, [stop]]) -> integer -- return first index of value.
 |      Raises ValueError if the value is not present.
 |
 |  insert(...)
 |      L.insert(index, object) -- insert object before index
 |
 |  pop(...)
 |      L.pop([index]) -> item -- remove and return item at index (default last).
 |      Raises IndexError if list is empty or index is out of range.
 |
 |  remove(...)
 |      L.remove(value) -> None -- remove first occurrence of value.
 |      Raises ValueError if the value is not present.
 |
 |  reverse(...)
 |      L.reverse() -- reverse *IN PLACE*
 |
 |  sort(...)
 |      L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __hash__ = None

Process finished with exit code 0

help() --样例

  • divmod() －－返回值和余数
res = divmod(100,9)    ## 100 除以 9
print(res)             #值为11 余数为1

print(eval("100/9"))   #直接相除的结果

＃＃显示如下：
(11, 1)
11.11111111111111

Process finished with exit code 0
  • enumerate() －－自动遍历对象，返回一个enumetate类型，参数是可以遍历的类型，如字典，列表等，如下：
product_list = [
    (‘aaa‘, 88),
    (‘bbb‘, 800),
    (‘ccc‘, 123),
    (‘ddd‘, 22222),
    (‘eee‘,12),
]

for item,tup in enumerate(product_list):
    print(item,tup)

# 输入如下：
0 (‘aaa‘, 88)        ＃前面的数子 0 ， 1 ，2等为自动添加的
1 (‘bbb‘, 800)
2 (‘ccc‘, 123)
3 (‘ddd‘, 22222)
4 (‘eee‘, 12)

Process finished with exit code 0
  • isinstence() -- 用来判断某个对象是否为某个类的实例－－ 返回true or false
s = "hellp 赵文成"
li = [1,2,3,4,5]

print(isinstance(s, str))
print(isinstance(li, str))
print(isinstance(li,list))
print(isinstance(s,list))

＃显示结果如下：
True
False
True
False

Process finished with exit code 0
  • filter() -- 用法：filter(函数名，可迭代对象)，循环可迭代的对象作为参数传递到函数中，如果函数的返回值true则视为此参数为符合筛选条件。使用场景为筛选如下：

要求为将列表中的数值中大于22的值快速筛选出来：

def fun(a):
    if  a > 22:        ＃定义返回true的条件
        return True

li = [11,22,33,44,55,66]
rest = filter(fun,li)
print(list(rest))

＃显示如下：
[33, 44, 55, 66]

Process finished with exit code 0

对于如上比较简单的函数可以用lambda表达式来代替，实现上面的功能可以用如下简单语句：

def fun(a):                             ＃不采用lambda表达式
    if  a > 22:
        return True

li = [11,22,33,44,55,66]
rest = filter(fun,li)
print(list(rest))

rest2 = filter(lambda a:a>22,li)  ＃采用lambda表达式
print(list(rest2))

＃显示结果如下：
[33, 44, 55, 66]
[33, 44, 55, 66]

Process finished with exit code 0
  • map() --跟filter相比，map是在执行，而不是在筛选。如下

将上面的列表中的各个元素的值在加1，如下：

def fun(a):
    a += 1
    return a

li = [11,22,33,44,55,66]
rest = map(fun,li)
print(list(rest))

＃显示结果如下：
[12, 23, 34, 45, 56, 67]    ＃每个值在原先的基础上增加了1

Process finished with exit code 0
  • locals -- 获取当前的局部变量（只读）
  • globals -- 获取全局变量（非只读）

当引用一个变量时按照 局部 －》全局 －》内置的顺序来查找，如果还找不到的话，则会抛出NameError。 如下为获取结果值：

NAME = "zhaowencheng"
def test():
    a = 1
    b = 2
    c = "sss"
    print("ceshi")

    print(globals())
    print(locals())

test()

＃分别显示如下：
ceshi
{‘NAME‘: ‘zhaowencheng‘, ‘__package__‘: None, ‘__name__‘: ‘__main__‘, ‘__spec__‘: None, ‘__cached__‘: None, ‘__doc__‘: None, ‘test‘: <function test at 0x10137b6a8>, ‘__loader__‘: <_frozen_importlib_external.SourceFileLoader object at 0x1007a5cc0>, ‘__file__‘: ‘/Users/wenchengzhao/PycharmProjects/s13/day4/test.py‘, ‘__builtins__‘: <module ‘builtins‘ (built-in)>}
{‘b‘: 2, ‘a‘: 1, ‘c‘: ‘sss‘}   ＃局部

Process finished with exit code 0
  • hash（） －－ 返回hash后的结果如下：
s = "zhaowencheng"
print(hash(s))

#显示如下：
4279979865803674610

Process finished with exit code 0
  • sum()   - 求和
  • max()　－取最大值
  • min()　－取最小值
li = [1,2,3]
print(max(li))
print(min(li))
print(sum(li))
＃显示如下
3
1
6

Process finished with exit code 0
  • len（） －长度
name = "赵文成"
print(len(name))   ＃数值按字符计算

name_b = bytes(name,encoding="utf8")
print(len(name_b))    ＃数值按照字节计算

#显示如下：
3
9
  • pow()
rest1 = pow(2,10)
rest2 = 2 ** 10
print(rest1)
print(rest2)

# 显示如下：
1024
1024
  • range（） － 生成一个数值序列
for i in range(5):
    print(i)

 ＃显示结果如下：
0
1
2
3
4

Process finished with exit code 0

当对某个对象进行循环是一半结合了len（）很常用如下：

a = [1,2,3,4,5,6,7,"a","b","c"]
for i in range(len(a)):
    print(a[i])

#显示结果如下：
1
2
3
4
5
6
7
a
b
c

Process finished with exit code 0
  • reversed() -  反转
a = [1,2,3,4,5,6,7,"a","b","c"]
b = reversed(a)
print(list(b))

＃显示如下：
[‘c‘, ‘b‘, ‘a‘, 7, 6, 5, 4, 3, 2, 1]

Process finished with exit code 0
  • round()  － 四舍五入
a = 13.6
b = 13.4
print(round(a))
print(round(b))
＃显示如下：
14
13

Process finished with exit code 0
  • zip() - 他接受一系列可迭代的对象作为参数，然后将对象中对应的元素打包成一个个tuple（元组），并统一放倒一个列表中：
q1 = ["李明",11,22,33]
q2 = ["李雷",11,22,33]
q3 = ["王梅梅",11,22,33]

r = zip(q1,q2,q3)
temp = list(r)
print(temp)

＃显示如下
[(‘李明‘, ‘李雷‘, ‘王梅梅‘), (11, 11, 11), (22, 22, 22), (33, 33, 33)]

Process finished with exit code 0

二.装饰器

装饰器其实就是函数，只不过该函数可以具有特殊的含义，装饰器用来装饰函数或类，使用装饰器可以在函数执行前和执行后添加相应操作（如判断某个条件是否满足）。

简单的来说在不修改原函数的情况下，在对原函数进行包装！

模拟应用场景如下：

初创公司有N个业务部门，1个基础平台部门，基础平台负责提供底层的功能，如：数据库操作、redis调用、监控API等功能。业务部门使用基础功能时，只需调用基础平台提供的功能即可。如下：

 1 ###########基础平台提供的功能############
 2 def f1():
 3     print ("f1")
 4
 5 def f2():
 6     print ("f2")
 7
 8 def f3():
 9     print ("f3")
10
11 def f4():
12     print ("f4")
13
14 ###业务部门A调用基础平台的功能###
15 f1()
16 f2()
17 f3()
18 f4()
19
20 ###业务部门B调用基础平台的功能###
21 f1()
22 f2()
23 f3()
24 f4()

变动需求来了：由于基础平台的提供的功能可以被任何人使用，现在需要对基础平台的所有功能进行重构，为平台提供的所有功能添加验证机制，即：执行功能前，先进行验证。

解决方法：

  • 1.跟所有的业务部门沟通，让它们在调用时先进行验证，这样基础平台这边就不用进行代码的调整，结果可想而之。。。。（逃避问题，并没有解决）
  • 2.逐个在基础平台的功能代码里添加验证代码代码如下，费时费力－解决太low

###########基础平台提供的功能############
def f1():
    #验证1
    #验证2
    #验证3
    print ("f1")

def f2():
    #验证1
    #验证2
    #验证3
    print ("f2")

def f3():
    #验证1
    #验证2
    #验证3
    print ("f3")

def f4():
    #验证1
    #验证2
    #验证3
    print ("f4")

##其他业务部门调用不变

解决代码 － 2

  • 3.单独写一个用于校验的函数，然后再吧check的功能添加到各个基础功能的函数中   －能够解决但是这样做同样违反了 封闭和开放的原则：

　　　　开放：对扩展开放

　　      封闭：对意境实现的代码功能封闭

　　第三种代码实现如下：

 1 ###########基础平台提供的功能############
 2 def check_login ():
 3     #验证1
 4     #验证2
 5     #验证3
 6
 7 def f1():
 8     check_login()
 9     print ("f1")
10
11 def f2():
12     check_login()
13     print ("f2")
14
15 def f3():
16     check_login()
17     print ("f3")
18
19 def f4():
20     check_login()
21     print ("f4")
22
23 ##其他业务部门调用不变

代码解决－3

  • 4.请－－－ 装饰器登场 ！！！－－ 根据上面的原则 不能再修改基础平台原先的已经实现了的功能了。

 1 ###########基础平台提供的功能############
 2 def w1(func):
 3     def inner():
 4         print("#验证1")
 5         print("#验证2")
 6         print("#验证3")
 7         return func()
 8     return inner
 9
10 @w1
11 def f1():
12     print ("f1")
13
14 @w1
15 def f2():
16     print ("f2")
17
18 @w1
19 def f3():
20     print ("f3")
21
22 @w1
23 def f4():
24     print ("f4")
25
26 ##其他业务部门调用不变
27 ###业务部门A调用基础平台的功能###
28 f1()
29 f2()
30 f3()
31 f4()
32
33 ##
34 print(" "*3)
35 ###业务部门B调用基础平台的功能###
36 f1()
37 f2()
38 f3()
39 f4()
40
41 ####################################
42 ##执行结果如：
43 #验证1
44 #验证2
45 #验证3
46 f1
47 #验证1
48 #验证2
49 #验证3
50 f2
51 #验证1
52 #验证2
53 #验证3
54 f3
55 #验证1
56 #验证2
57 #验证3
58 f4
59
60 #验证1
61 #验证2
62 #验证3
63 f1
64 #验证1
65 #验证2
66 #验证3
67 f2
68 #验证1
69 #验证2
70 #验证3
71 f3
72 #验证1
73 #验证2
74 #验证3
75 f4
76
77 Process finished with exit code 0

解释器－解决代码

完美！！－－ 对于第四总方法，也是仅仅对基础平台的代码进行了修改，就玩去能够实现其他部门在调用这些函数时都先进行验证，并且其他调用部门是完全不用修改任何代码。

对于详细的实现过程，和实现方法如下：

单独以f1为例说明如下：

###########基础平台提供的功能############
def w1(func):
    def inner():
        print("#验证1")
        print("#验证2")
        print("#验证3")
        func()
        print("end")
    return inner

@w1
def f1():
    print ("f1")

@w1
def f2():
    print ("f2")

@w1
def f3():
    print ("f3")

@w1
def f4():
    print ("f4")

##其他业务部门调用不变
###业务部门A调用基础平台的功能###
f1()

从这段代码的执行顺序看：

1.def w1(func):  将w1函数加载到内存中

[email protected]  －－－ python 中语法糖 具体会执行如下操作：

  • 执行w1函数，并将@下面的函数的函数名作为w1函数的参数 ，相当于 w1（f1）

　　　　所以，内部就会去执行：
    　　　　def inner:
        　　　　#验证
        　　　　return f1()   # func是参数，此时 func 等于 f1
    　　　　return inner     # 返回的 inner，inner代表的是函数，非执行函数
　　　　其实就是将原来的 f1 函数塞进另外一个函数中

  • 将执行完的w1函数返回值赋值给@w1下面的函数的函数名

　　　　w1函数的返回值是：
   　　　　def inner:
        　　　　#验证
        　　　　return 原来f1()  # 此处的 f1 表示原来的f1函数
　　　　然后，将此返回值再重新赋值给 f1，即：
　　　　新f1 = def inner:
            　　　　#验证
            　　　　return 原来f1() 
所以，以后业务部门想要执行 f1 函数时，就会执行 新f1 函数，在 新f1 函数内部先执行验证，再执行原来的f1函数，然后将 原来f1 函数的返回值 返回给了业务调用者。
如此一来， 即执行了验证的功能，又执行了原来f1函数的内容，并将原f1函数返回值 返回给业务调用着

进阶：带参数的装饰器

  • 1个参数：
 1 def w1(func):
 2     def inner(arg1):
 3         print("#验证1")
 4         print("#验证2")
 5         print("#验证3")
 6         func(arg1)
 7         print("end")
 8     return inner
 9
10 @w1
11 def f1(arg1):
12     print ("f1","-->",arg1)
13
14
15
16 f1("这是一个参数的")
  • 2个参数：
###########基础平台提供的功能############
def w1(func):
    def inner(arg1,arg2):
        print("#验证1")
        print("#验证2")
        print("#验证3")
        func(arg1,arg2)
        print("end")
    return inner

@w1
def f1(arg1,arg2):
    print ("f1","-->",arg1,arg2)

f1("这是一个参数的","增加了第二个参数")
  • 3.三个参数的：
###########基础平台提供的功能############
def w1(func):
    def inner(arg1,arg2,arg3):
        print("#验证1")
        print("#验证2")
        print("#验证3")
        func(arg1,arg2,arg3)
        print("end")
    return inner

@w1
def f1(arg1,arg2,arg3):
    print ("f1","-->",arg1,arg2,arg3)

f1("这是一个参数的","增加了第二个参数","增加了第三个参数")
  • 4.？？n个参数？？如何处理 －－－ “万能参数”装饰器
###########基础平台提供的功能############
def w1(func):
    def inner(*args,**kwargs):
        print("#验证1")
        print("#验证2")
        print("#验证3")
        func(*args,**kwargs)
        print("end")
    return inner

@w1
def f1(*args,**kwargs):
    print ("f1","-->",args)
    print(kwargs)

f1("一个参数的","二个参数","第三个参数","....","n个参数的",key="value")

####输出如下

#验证1
#验证2
#验证3
f1 --> (‘一个参数的‘, ‘二个参数‘, ‘第三个参数‘, ‘....‘, ‘n个参数的‘)
{‘key‘: ‘value‘}
end
时间： 2024-10-14 04:48:56

文成小盆友python-num4 内置函数的相关文章

Python 常用内置函数

abs 取绝对值 print(abs(-1)) #结果1 all(...) all(iterable) -> bool Return True if bool(x) is True for all values x in the iterable. If the iterable is empty, return True. 如果iterable的所有元素不为0.''.False或者iterable为空,all(iterable)返回True,否则返回False:函数等价于: 1 def all

python D13 内置函数

# 1.内置函数# 什么是内置函数? 就是python给你提供的. 拿来直接?的函数, 比如print., input等等. 截?# 到python版本3.6.2 python?共提供了68个内置函数. 他们就是python直接提供给我们的. 有# ?些我们已经?过了. 有?些还没有?过. 还有?些需要学完了?向对象才能继续学习的. 今# 天我们就认识?下python的内置函数. # 不熟悉的函数:# eval() 执?字符串类型的代码. 并返回最终结果# print(eval("2+2&quo

Python 集合内置函数大全（非常全！）

Python集合内置函数操作大全 集合(s).方法名 等价符号 方法说明 s.issubset(t) s <= t 子集测试(允许不严格意义上的子集):s 中所有的元素都是 t 的成员   s < t 子集测试(严格意义上):s != t 而且 s 中所有的元素都是 t 的成员 s.issuperset(t) s >= t 超集测试(允许不严格意义上的超集):t 中所有的元素都是 s 的成员   s > t 超集测试(严格意义上):s != t 而且 t 中所有的元素都是 s 的成

python常用内置函数学习（持续更新...）

python常用内置函数学习 一.python常用内置函数有哪些 dir() 二.每个内置函数的作用及具体使用 1.dir()不带参数时返回当前范围内(全局.局部)的变量.方法和定义的类型列表:   带参数A时返回参数的属性.方法的列表,如何该参数A对象有__dir__(),该方法被调用,如果不含有该方法,该方法不会报错,而是尽可能多的收集参数对象A的信息   实例: 不带参数,在分别在文件全局调用和在函数中局部调用dir()   带参数   原文地址:https://www.cnblogs.c

文成小盆友python-num3 集合，函数，-- 部分内置函数

本接主要内容: set -- 集合数据类型 函数 自定义函数 部分内置函数 一.set 集合数据类型 set集合,是一个无序且不重复的元素集合 集合基本特性 无序 不重复 创建集合 #!/bin/env python s1 = {"1","2","3","4"} ##或者 s2 = set() set 提供的功能 1 class set(object): 2 """ 3 set() -> n

Python基础----内置函数补充、匿名函数、递归函数

内置函数补充 python divmod()函数:把除数和余数运算结果结合起来,返回一个包含商和余数的元组(a // b, a % b) 语法: 1 divmod(a, b) #a.b为数字,a为除数,b为被除数 示例: 1 >>> divmod(7, 2) 2 (3, 1) #3为商,1为余数 3 >>> divmod(7, 2.5) 4 (2.0, 2.0) 应用:web前端页数计算 1 total_count=73 2 per_count=23 3 res=div

Python菜鸟之路一：Python基础-内置函数补充

常用内置函数及用法: 1. callable() def callable(i_e_, some_kind_of_function): # real signature unknown; restored from __doc__ """检查对象object是否可调用.如果返回True,object仍然可能调用失败:但如果返回False,调用对象ojbect绝对不会成功 Return whether the object is callable (i.e., some kin

【Python】内置函数清单

Python内置(built-in)函数随着python解释器的运行而创建.在Python的程序中,你可以随时调用这些函数,不需要定义.最常见的内置函数是: print("Hello World!") 在Python教程中,我们已经提到下面一些内置函数: 基本数据类型 type() 反过头来看看 dir() help() len() 词典 len() 文本文件的输入输出 open() 循环设计 range() enumerate() zip() 循环对象 iter() 函数对象 map

装饰器、生成器、迭代器、及python中内置函数的使用

一. 装饰器 1. 装饰器的概述 (1)概述:装饰器本质就是函数,主要用来装饰其他函数,为其他函数添加附加功能. (2)使用装饰器的原则 1)不能修改被装饰的函数的源代码 2)不能修改被装饰的函数的调用方式 (3)装饰器原理:函数即"变量".高阶函数.嵌套函数 2.使用装饰器的原因 (1)传统的多个函数模块修改需要同时修改多个函数.如果函数过多,则修改不方便. 如下,如果想要在每个函数中开头结尾分别输入内容,则需要在每个函数开头结尾加入需要输出的内容. def f1():     pr