Python（九）函数

本文主要是介绍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（九）函数的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！