# ### 函数
"""
概念:功能 (包裹一部分代码 实现某一个功能 达成某一个目的)
特点:可以反复调用,提高代码的复用性,提高开发效率,便于维护管理
"""
# 1.函数基本格式
"""
# 定义一个函数
def 函数名():
code1
code

# 调用函数
函数名()
"""

# 定义函数
def func():
print("我是一个函数 ... ")

# 调用函数
func()

# 2.函数的命名
"""
字母数字下划线,首字符不能为数字
严格区分大小写,且不能使用关键字
函数命名有意义,且不能使用中文哦

驼峰命名法:
(1) 大驼峰命名法: 每个单词的首字符要大写 (类的命名)
mycar => MyCar
(2) 小驼峰命名法: 除了第一个单词首字符小写外,剩下单词首字符大写 (函数或者变量)
mycar => myCar
_命名法:可以将不同的单词用_拼接在一起
mycar => my_car
symmetric_differencesymmetricDifference SymmetricDifference
"""

# 函数定义
def cfb_99():
for i in range(1,10):
for j in range(1,i+1):
print("{:d}*{:d}={:2d} ".format(i,j,i*j) ,end="")
print()
# 调用函数
for i in range(5):
cfb_99()

# ### 函数的参数
"""
参数: 函数运算时需要的值

参数种类:
(1)形参: 形式参数,在函数的定义处
(2)实参: 实际参数,在函数的调用处

形参的种类:
1.普通形参(位置形参) 2.默认形参 3普通收集形参 4.命名关键字形参 5.关键字收集形参
实参的种类:
1.普通实参 2.关键字实参

原则:
形参和实参要一一的对应
"""

# 1.普通形参(位置形参)
# 定义函数
"""hang,lie普通形参,在函数定义处"""
def small_star(hang,lie):
i = 0
while i < hang:
j = 0
while j < lie:
print("*",end="")
j +=1
print()
i += 1
# 调用函数
"""10,10普通实参,在函数的调用处"""
small_star(10,10)
small_star(2,3)

# 2.默认形参
"""hang,lie默认形参,在函数定义处"""
"""
如果给予实参,那么使用实参
如果没有给予实参,那么使用参数身上的默认值
"""
def small_star(hang=10,lie=10):
i = 0
while i < hang:
j = 0
while j < lie:
print("*",end="")
j +=1
print()
i += 1

small_star(4,8)
small_star(8)
small_star()

# 3.普通形参 + 默认形参
"""普通形参必须写在默认形参的前面不能调换位置"""
def small_star(hang,lie=10):
i = 0
while i < hang:
j = 0
while j < lie:
print("*",end="")
j +=1
print()
i += 1
small_star(5,7)
# small_star(5)
# small_star() error

# 4.关键字实参
print("<=============>")
"""
1.如果都是关键字实参,可以任意调整实参的顺序
2.普通实参必须写在关键字实参的前面
"""
def small_star(hang,a,b,c,lie=10):
i = 0
while i < hang:
j = 0
while j < lie:
print("*",end="")
j +=1
print()
i += 1

# hang a ... lie 具体指定参数的值叫做关键字实参,在函数的调用处;
# small_star(hang=3,a=4,b=5,c=6,lie=7)
# small_star(b=5,c=6,lie=7,a=4,hang=3)
small_star(3,4,b=5,c=6,lie=7)
small_star(3,4,b=5,lie=7,c=6)
# small_star(b=5,c=6,lie=7,3,4) error

# ### 收集参数
"""
(1) 普通收集形参: 专门用来收集那些多余的没人要的普通实参
收集之后,会把多余实参打包成一个元组
参数头上1个星星
def func(*args):
pass
args => arguments
"""
def func(a,b,c,*args):
print(a,b,c) # 1 2 3
print(args) # (4,5,6)

func(1,2,3,4,5,6)

# 任意个数值得累加和
def mysum(*args):
total = 0
for i in args:
total += i
print(total)
mysum(1,2,3,4,4,45,10,100)

"""
(2) 关键字收集形参:专门用来收集那些多余的没人要的关键字实参
收集之后,会把多余关键字实参打包成一个字典
参数头上有2个星星
def func(**kwargs):
pass
kwargs => keyword arguments
"""

def func(a,b,c,**kwargs):
print(a,b,c)
print(kwargs) # {'f': 100, 'e': 200, 'z': 12}
func(c=1,a=3,b=10,f=100,e=200,z=12)

# 拼接任意个数值变成字符串
"""
班长: 赵万里
班花: 马春陪
划水群众: 赵沈阳,李虎凌,刘子涛
"""
def func(**kwargs):
strvar1 = ""
strvar2 = ""
# 定义职位信息
dic = {"monitor":"班长","classflower":"班花"}
print(kwargs)
# 共5次循环
for k,v in kwargs.items():
if k in dic:
# 将2次循环的结果通过+= 拼接在一起
strvar1 += dic[k] + ":" + v + "\n"
else:
# 将3次循环的结果通过+= 拼接在一起
strvar2 += v + " , "
print(strvar1.strip())
print("划水群众:",strvar2.strip(" , "))

"""
# print(k,v)
k v
monitor 赵万里
classflower 马春陪
water1 赵沈阳
water2 李虎凌
water3 刘子涛
{'monitor': '赵万里', 'classflower': '马春陪', 'water1': '赵沈阳', 'water2': '李虎凌', 'water3': '刘子涛'}
"""

func(monitor="赵万里",classflower="马春陪",water1="赵沈阳",water2="李虎凌",water3="刘子涛")

# ### 命名关键字参数
"""
(1) def func(a,b,*,c,d) 跟在*号后面的c和d是命名关键字参数
(2) def func(*args,e,**kwargs) 加在*args和**kwargs之间的参数都是命名关键字参数

命名关键字参数 : 在调用函数时,必须使用关键字实参的形式来进行调用;
"""
# 定义方法一
def func(a,b,*,c,d):
print(a,b)
print(c,d)

# 必须指定关键字实参,才能对命名关键字形参进行赋值
func(1,2,c=3,d=4)

# 定义方法二
def func(*args,e,**kwargs):
print(args) # (1, 2, 3, 4)
print(e) # 3
print(kwargs) # {'a': 1, 'b': 2}
func(1,2,3,4,a=1,b=2,e=3)

# ### 星号的使用
"""
* 和 ** 如果在函数的定义处使用:
* 把多余的普通实参打包成元组
** 把多余的关键字实参打包成字典

* 和 ** 如果在函数的调用处使用:
* 把元组或者列表进行解包
** 把字典进行解包
"""

def func(a,b,*,c,d):
print(a,b)
print(c,d)

tup = (1,2)
# 函数的调用处 *号用法
func(*tup,c=3,d=4) # func(1,2,c=3,d=4)

# 函数的调用处 **号用法
dic={"c":3,"d":4}
func(1,2,**dic) # func(1,2,c=3,d=4)

# 综合写法
# 函数的调用处
tup = (1,2)
dic={"c":3,"d":4}
func(*tup,**dic)

# 定义成如下形式,可以收集所有的实参
def func(*args,**kwargs):
pass

# 总结: 当所有的形参都放在一起的时候,顺序原则:
"""
普通形参 -> 默认形参 -> 普通收集形参 -> 命名关键字形参 -> 关键字收集形参
"""

def f1(a, b, c=0, *args, **kw):
print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

def f2(a, b, c=0, *, d, **kw):
print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
# 以上两个函数 打印结果
#(一)
f1(1, 2) # a =1 b=2 c=0 args=() kw={}
f1(1, 2, c=3) # a=1,b=2,c=3,args=() kw={}
f1(1, 2, 3, 'a', 'b') #a=1 b=2 c=3 args=(a,b) kw={}
f1(1, 2, 3, 'a', 'b', x=99) # a=1 b=2 c=3 args=(a,b) kw={x:99}
f2(1, 2, d=99, ext=None)#a=1 b=2 c=0 d=99 kw={ext:None}

#(二)
args = (1, 2, 3, 4)
kw = {'d': 99, 'x': '#'}
# f1(1,2,3,4,d=99,x=#)
f1(*args, **kw) # a=1 b=2 c=3 args=(4,) kw={d:99,x:#}

#(三)
myargs = (1, 2, 3)
mykw = {'d': 88, 'x': '#'}
# f2(1,2,3,d=88,x=#)
f2(*myargs, **mykw) # a=1,b=2,c=3 d=88 kw={x:#}

#(四)
def f1(a, b, c=0, *args,d,**kw):
print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
print(d)

f1(1,2,3, 'a', 'b',d=67, x=99,y=77) # a=1 b=2 c=3 args=(a,b) kw={x:99,y:77}
# d=67

# ### return 自定义函数的返回值
"""
概念:return 把函数内部的数据返回到函数的外面,返回到函数的调用处
1.return + 六大标准数据类型 , 除此之外还可以返回函数 或者 是类对象
2.return 在执行时,意味着终止函数,后面的代码不执行.
3.如果不定义return返回值,默认返回None
"""

# (1) return + 六大标准数据类型
def func():
# return 111
# return 6.89
# return "你好帅啊,我爱死你乐"
# return [1,2,3]
# return {"a":1,"b":2}
return 1,2,3 # 返回元组
res = func()
print(res)

# (2) return 在执行时,意味着终止函数,后面的代码不执行.
def func():
print(1)
print(2)
return 3
print(4)
res = func()
print(res)

def func():
for i in range(5):
if i == 3:
return 4
print(i)
res = func()
print(res)

# (3) 如果不定义return返回值,默认返回None
def func():
pass

res = func()
print(res) # None

# 注意点 打印的数据和返回的数据不是等价的,返回的数据是可以自定义的;
res = print(1234)
print(res) # None

# 模拟+-*/计算器
"""
功能: 完成计算
参数: 2个数字和运算符
返回值: 计算后的结果
"""
def calc(num1,num2,sign):
if sign == "+":
return num1 + num2
elif sign == "-":
return num1 - num2
elif sign == "*":
return num1 * num2
elif sign == "/":
if num2 == 0:
return "除数不能为零"
return num1 / num2
else:
return "抱歉,超出了我的运算范围."

res = calc(3,5,"+")
res = calc(3,5,"-")
res = calc(3,5,"*")
res = calc(3,0,"/")
res = calc(3,0,"&")
print(res)

# 全局变量和局部变量
"""
局部变量:在函数内部定义的变量就是局部变量
全局变量:在函数外部内定的变量或者在函数内部使用的global关键字声明是全局变量（只有python可以）

作用域：
局部变量的作用范围仅仅在函数的内部
全局变量的作用范围横跨整个文件

生命周期：该变量的作用时长
内置命名空间 > 全局命名空间 > 局部命名空间
内置属性>全局属性>局部属性(作用时长：从长到短)
"""
# 1 局部变量
def func():
# 定义一个局部变量
a = 1
# 获取当前的局部变量
print(a)
# 修改一个局部变量
a = 2
print(a)
func()
# print(a) # 报错 name a 没有被定义过 局部变量只可以在函数内部使用

# 2.全局变量
# 定义一个全局变量
b = 10
# 获取当前的全局变量
print(b)
# 修改一个全局变量
b = 20
print(b)

def func():
print(b) # 这样不会执行 因为函数没有被调用

def func():
print(b)
func()

#3. 函数内部定义全局变量
def func():
global c #定义c是全局变量
c = 10
func()
print(c)

# 4. 函数内部修改全局变量
d = 50
def func():
d = 51 # 只在内部生效
func()
print(d) # 打印结果为50

d = 50
def func():
global d
d = 51
func()
print(d) # 打印结果为51

"""
总结：global
如果当前不存在全局变量，可以再函数内部通过global关键字来定义全局变量
如果当前存在全局变量 ，可以再函数内部通过global关键字来修改全局变量
"""

##函数名的使用
# python中的函数可以像变量一样,动态创建,销毁,当参数传递,作为值返回,叫第一类对象.其他语言功能有限
def func():
print("我是func函数")
#(1)动态创建
a = 1
print(a)
a = func # 函数赋值给变量a 此时a也变成了函数 python特有 python很灵活
a = ()

# (2)动态销毁
del a
#a()
#func()

#(3)当参数传递
def func2():
print("我是fucn2函数") # 也可以这样写 return "我是fucn2函数"
def func1(f):
f() # 也可以这样写 return f()
res = func1(func2)
print(res)

(4)作为返回值
def func3():
print("我是func3函数")

def func4(f):
return f

res = func4(func3)
print(res)
res()

#(5)函数名可以作为容器小类型数据的元素
lst = [func,func3]
for i in lst:
i()

###### __doc__ 或者help查看文档
def big_chang_cishen(something):
"""
功能：教你怎么吃大肠
参数：吃的内容
返回值：是否满意
"""
print("把{}洗一洗".format(something))
print("直接找场子头,放嘴里,吸一下")
print("擦擦嘴,满意的放下肠子头")
return "吃完了,真好吃"

big_chang_cishen("生肠子")
#方法一：
res = big_chang_cishen.__doc__ # 查看自己写的注释描述文档内容
print(res)
# 方法二：
help(big_chang_cishen)

### 函数的嵌套

"""
互相嵌套的两个函数：
包裹在外层的叫做外函数，内存的就是内函数
"""
def outer():
def inner():
print("我是inner函数")
inner()

(1)内部函数可以直接在函数外部调用么
inner() # 不可以调用 只能在内部使用
(2)调用外部函数后,内部函数可以在函数外部调用吗
outer()
inner()
# 不可以
(3)内部函数可以在函数内部调用吗
#可以
(4)内部函数在函数内部调用时,是否有先后顺序
有，需要先定义在调用 ，其他语言可以 ，其他语言有预加载机制，提前把函数驻留到内存中，然后再去编译脚本内容
python没有预加载的机制，只能先定义在调用

#外部是outer 中间是 inner 最里层是smaller，调用smaller函数
def outer():
def inner():
def smaller():
print("我是smaller")
smaller()
inner()
outer()

LEGB原则(即就近原则找变量)
#找寻变量的调用顺序采用LEGB原则(即就近原则)
B —— Builtin(Python)；Python内置模块的命名空间 (内建作用域)
G —— Global(module)； 函数外部所在的命名空间 (全局作用域)
E —— Enclosing function locals；外部嵌套函数的作用域(嵌套作用域)
L —— Local(function)；当前函数内的作用域 (局部作用域)
依据就近原则,从下往上 从里向外 依次寻找

LEGB原则
def outer():

def inner():

def smaller():

print(a)
smaller()
inner()
outer()

### nonlocal的使用(用来修改局部变量)
"""
遵循LEGB原则
(1)他会找当前空间上一次变量进行修改
(2)如果上一层空间没有，继续向上寻找
(3)如果最后找不到，直接报错
"""
(1)他会找当前空间上一次变量进行修改
def outer():
a = 10
def inner():
a = 20
print(a)
inner()
print(a)
outer()
打印结果： 20 10

使用nonlocal进行修改
def outer():
a = 10
def inner():
nonlocal a
a = 20
print(a)
inner()
print(a)
outer()
打印结果： 20 20

(2)如果上一层空间没有，继续向上寻找
def outer():
a = 20
def inner(): # 没找到a 继续向上寻找
def smaller():
nonlocal a
a = 30
print(a)
smaller()
print(a)
inner()
print(a)
outer()
打印结果：30 30 30

(3)如果最后找不到，直接报错
a = 20
def outer():
def inner():
def smaller():
nonlocal a
a = 30
print(a)
smaller()
print(a)
inner()
print(a)
outer()
#打印结果：报错 找不到变量a 因为nonlocal 只能修改局部变量

(4)不通过nonlocal是否可以修改局部变量呢？

def outer():
lst = [1,2,3]
def inner():
lst[-1] = 30
inner()
print(lst)
print(a)
outer