Python(九)函数

2022/1/15 14:05:12

本文主要是介绍Python(九)函数,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

'''
--  name:Lonelyroots  --
--  不同内容空三行  --
--  同一内容不同知识点空二行  --
--  程序内部空一行  --
'''
'''
内置函数:有自己的功能,可以直接调用
input()输入函数
print()输出函数
int() list() str()
'''
'''
def 定义函数,类似一个模具,函数里面代码不会执行
调用函数时,函数名(),才会执行函数里面的代码
函数的作用:
    (1)减少代码量,提供代码的复用性
'''
# # 函数的封装
# def cfb(n):     # n*n乘法表
#     # 函数体
#     for i in range(1,n+1):
#         for j in range(1,i+1):
#             print('{0}*{1}={2}'.format(i,j,i*j),end='\t')
#         print()
# # 函数的调用
# cfb(9)      # 九九乘法表


# def fun(x,y):       # def 定义函数 函数名():
#     #缩进里面的代码,是属于该函数的功能
#     print(x+y)
# fun(5,6)
'''
函数的参数,在定义函数时传入的参数,就是函数的参数
必备参数、默认参数、不定长参数(元组不定长、字典不定长)
参数的定义顺序(必须遵守):1、必备参数,2、默认参数,3、元组不定长,4、字典不定长
'''
# # 在函数调用的过程中,必须传的值叫做必备参数
# def func(x):
#     print(x)
# func(6)


# # 在定义函数时,给定了值,这个值叫做默认参数
# def funb(x = 10):
#     print(x)
# funb()      # 10
# funb(9)     # 9


# def fund(x,y = 5):
#     print(x+y)
# fund(2)     # 7
# fund(5,7)       # 12


# # 元组不定长
# def func(*args):        # *表示元组不定长
#     print(args)
# func()      # 输出空元祖()
# func(1)     # 输出(1,)
# func(1,2,'123',[4,5,7],{'a':5})     # 输出(1, 2, '123', [4, 5, 7], {'a': 5})


# # 字典不定长
# def fune(**kwargs):
#     print(kwargs)
# fune()      # 输出{}
# fune(a=5,b='1212',c=[1,5,7])      # 键值对 传值方式键=值 输出{'a': 5, 'b': '1212', 'c': [1, 5, 7]}


# def funz(x,y,n=10,*args,**kwargs):
#     print(x,end=' ')
#     print(y,end=' ')
#     print(n,end=' ')
#     print(args,end=' ')
#     print(kwargs,end=' ')
# funz(5,6)       # 5 6 10 () {}
# funz(5,6,7,8,[5,8],{'a':5,"k":18},b=7,g=10)     # 输出5 6 10 () {} 5 6 7 (8, [5, 8], {'a': 5, 'k': 18}) {'b': 7, 'g': 10}
'''
函数返回值
return:
    1、结束函数,属于函数里面的return下面的代码不会执行
    2、return 返回值
    3、没有加return之前,函数调用没有值返回
函数没有加return的时候,没有返回值,也就是None
函数返回的是什么值,取决于return后面的数据
'''
# def funa():
#     print("如果你追到我")
#     print("我就和你嘿嘿嘿")
#     print("小黑屋里斗地主")
# a = funa()
# print(a)        # None


# def fun():
#     print("如果你追到我")
#     return 5
#     print("我就和你嘿嘿嘿")
#     print("小黑屋里斗地主")
# fun()
# a = fun()
# print(a)        # 5
'''
函数的作用域:
    全局作用域:在文件里面
    局部作用域:在函数里面
    x = 10可以理解为全局变量
    a = 5可以理解为局部变量
    声明函数外部的变量:global
【注】用global声明全局变量以后,函数内部可以修改全局变量。但不可以修改针对的是不可变数据、数值,元组这些,列表、字典不需要global声明就可以修改
'''
# x = 10
# def func():
#     # 局部变量
#     a = 5
#     # 用global声明全局变量以后,函数内部可以修改全局变量
#     global x
#     # 局部作用域
#     x += 1      # 函数内部是可以访问外部变量(全局变量),但不可以修改
#     print(x)
# func()


# # 但不可以修改针对的是不可变数据、数值
# # 列表、字典还是可以直接修改的
# y = [5,7,8]
# def funb():
#     y.append(9)
#     print(y)
# funb()
'''
函数嵌套函数:
    对于函数嵌套函数,要去声明函数内的变量:nonlocal
    nonlocal声明外部嵌套函数内的变量
'''
# b = 100
# def fund():
#     global b    # 用global声明py文件里(函数外部)的全局变量
#     b += 1
#     a = b
#     def fune():
#         nonlocal a      #用nonlocal声明外部嵌套函数内的变量
#         a += 1
#         print(a)        # 打印102
#     fune()
# fund()
'''
函数体 函数调用,func指的是函数本身:
    def func():
        print(123)
'''
# def fun():
#     def func():
#         print(123)
#     return func     # func指的是函数本身
# a = fun()       # a就是func,变量a接收fun()的return返回值即func
# print(a)        # <function fun.<locals>.func at 0x00000230067909D8>
# a()     # 即a()=func(),调用func函数,打印123
'''
函数作用域-闭包:
    外层函数返回内层函数的函数体
为什么要使用闭包呢?以下方的例子说明:
    如果不把等级放在函数内部,则任何地方都可以修改,也就是外挂,所以需要把等级保护起来,要修改只能通过调用指定的函数,
这在一定的程度上保护了等级。
'''
# def diaochan():
#     lv = 1
#     def daguai():
#         nonlocal lv
#         lv += 1
#         return lv
#     return daguai
# a = diaochan()      # a是daguai这个函数体,因为函数是用return返回值,所以需要用变量接收
# print(a)    # <function diaochan.<locals>.daguai at 0x0000018D83AB0AE8>
# lv = a()     # 即daguai(),因为函数是用return返回值,所以需要变量接收
# print(lv)       # 打印2


# def diaochan():
#     lv = 1
#     def daguai():
#         nonlocal lv
#         lv += 1
#         return lv
#     def siwang():
#         nonlocal lv
#         lv -= 1
#         return lv
#     return daguai,siwang
# add,down = diaochan()      # add是daguai函数体,down是siwang函数体
# print(add)    # <function diaochan.<locals>.daguai at 0x00000283F9D90AE8>
# print(down)     # <function diaochan.<locals>.siwang at 0x000001DDAE360B70>
# ad = add()     # ad即daguai(),因为函数是用return返回值,所以需要变量接收
# do = down()     # do即siwang(),因为函数是用return返回值,所以需要变量接收
# print(ad,do)       # 打印2,1
'''
递归函数:函数自己调用自己
'''
# def rec(x):
#     if x <= 1:
#         return 1
#     else:
#         return x+rec(x-1)
# num = rec(5)    # 运行顺序:5+rec(4)->5+4+rec(3)->5+4+3+rec(2)->5+4+3+2+rec(1)->5+4+3+2+1=15
# print(num)
'''列表排序'''
# li = [1,7,5,'8','9']
# li.sort(key = str)      # key排序规则,会把列表里面所有的元素取出来转成字符串,在进行比对
# print(li)       # [1, 5, 7, '8', '9']
'''
匿名函数:lambda
    自带return
'''
# def f(x):
#     return x
# # 匿名函数 自带return
# a = f(2)
# print(a)        # 2

# # or
# g = lambda x:x      # 第一个x是调用函数传递的参数,后面的x是return返回的参数
# a = g(2)
# print(a)        # 2
'''
函数和列表排序一起使用
'''
# li = [7,5,1,'8','9']
#
# def f(x):
#     return str(x)
# # or
# f = lambda x:str(x)
#
# li.sort(key = f)    # 会把列表里面所有的元素取出来按照函数的规则,再进行比对
# print(li)
'''
统一计算:map()函数
'''
# def f(x):
#     return x*10
# res = map(f,[1,2,3,4,5])
# print(list(res))        # [10, 20, 30, 40, 50]


res = map(lambda x:x*10,[1,2,3,4,5])
print(list(res))        # [10, 20, 30, 40, 50]

文章到这里就结束了!希望大家能多多支持Python(系列)!六个月带大家学会Python,私聊我,可以问关于本文章的问题!以后每天都会发布新的文章,喜欢的点点关注!一个陪伴你学习Python的新青年!不管多忙都会更新下去!一起加油!



这篇关于Python(九)函数的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程