'''
-- 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的新青年！不管多忙都会更新下去！一起加油！
