10函数的基本操作

函数：对功能或者动作的封装（对一段代码进行封装）
	语法：
	def 函数名（形参）#创建函数
	    函数体->或者return
	
函数名（实参）#调用

返回值：
    1，不写return，没有返回值，返回None
    2，写了return，return后面没写值，返回是None
    3，写了return值，返回了一个值
    4，写了return值1，值2....（封装到元组中）
    返回值返回在哪里呢？返回到调用位置如(返回给变量a)：
        a = func()
        b = func()
参数：
    1，实参： a = func（a,b,c,d,e=1,f=2）
        1，位置参数
        2，关键字参数
        3，混合参数:顺序先位置，后关键字

2，形参：
    1，位置
    2，默认值参数
    3，动态传参，不确定参数的时候使用
            顺序：位置参数，*args，默认值参数，**kwargs
        *args
        **kwargs
 global 全局变量
 nonlocal 局部变量
 globals() 查看全局作用域中的内容
 locals() 查看当前作用域中的内容

#1、了解函数
# y = x + 1 # 当x=1的时候y=2
# f(x) = x +1
# f(1) = 2

# 2、函数：表示对功能或者动作的封装
# 语法
# def 函数名()：
#     函数体（具体的代码）
# 调用：
# 函数名（）

def una():
    print ("i love una")
    print ("i love guoguo")
    print ("i love yangyu")
    print ("i love gpc")
una()

# i love una
# i love guoguo
# i love yangyu
# i love gpc

# 3、函数的返回值
# return: 如果函数执行过程中执行了 return ，函数一定会中断，默认值也是None
# return值 这个值称为返回值，这种写法表示只有一个返回值
# return值1，值2，值3....表示可以有多个返回值，多个数据组织成一个元组
# return值什么也不写返回是None
# return None

def una():
    print ("i love una")
    print ("i love guoguo")
    return
    print ("i love yangyu")
    print ("i love gpc")
una()
# i love una
# i love guoguo

def una():
    print ("i love una")
    print ("i love guoguo")
    print ("i love yangyu")
    print ("i love gpc")
    return "大爱无疆"
love = una()
print ("你得返回值是",love)
# i love una
# i love guoguo
# i love yangyu
# i love gpc
# 你得返回值是 大爱无疆

def suzi():
    a = int (input(">>>"))
    b = int (input(">>>"))
    if a>b:
        return a
    else:
        return b
c = suzi()
print (c)
# >>>123
# >>>456
# 456
#--------------
# >>>888
# >>>555
# 888

# 4 、 函数的参数
def una(love):# 形参
    print ("i love %s"%love)
    print ("i love guoguo")
    print ("i love yangyu")
    print ("i love gpc")
    return "大爱无疆"
una("雨雨")#实参
# i love 雨雨
# i love guoguo
# i love yangyu
# i love gpc

# 参数：在调用函数的时候可以给函数传递信息
# 形参：在声明函数的时候，在小括号里写的变量（准备接受外界传递的信息）
# 实参：在执行函数的时候，给函数传递具体的值
# 形参和实参的数量要一一对应
# 实参
    # 1，位置参数
    # 2，关键字参数
    # 3，混合参数：先写位置再写关键字
    # def chi(zs,fs,t,s):
    #     print(zs)
    #     print (fs)
    #     print(t)
    #     print (s)
    #     pass
    # chi("大米","面包","鸡蛋汤","可乐")#位置参数
    # chi(fs="面包",zs="大米",t="鸡蛋汤",s="可乐")#关键字参数
    # chi("大米","面包",t="鸡蛋汤",s="可乐")# 混合参数

# 形参
# 顺序：
#     位置>*args>默认值>**kwargs
    # 1，位置参数
    # 2，默认值参数#当数据中出现的字符较多时候可以使用默认值参数
    # 3，动态传参
    #         *args 动态接受很多个参数，只能接受位置参数
    #         **kwags 动态接受多个关键字参数

def info(name,age,gender="男"):#gender默认值参数
    print (name,age,gender)
info("马云",18)
info("马华腾",28)
info("小泽玛利亚",18,"女")
# 马云 18 男
# 马华腾 28 男
# 小泽玛利亚 18 女

def chi(*args):#动态位置传参（收到的内容装入元组）
    print (args)
chi ("黄瓜","茄子","牛肉","大虾")
# ('黄瓜', '茄子', '牛肉', '大虾')

def chi(**kwags):#动态关键字传参（收到的内容装入字典）
    print (kwags)
chi (kwags = "黄瓜",kwags1 = "茄子",kwags2="牛肉",kwags3="大虾")
# {'kwags': '黄瓜', 'kwags1': '茄子', 'kwags2': '牛肉', 'kwags3': '大虾'}

 #   位置>*args>默认值>**kwargs
def func(a,b,c,*args,m="哈哈",**kwargs):
    print (a)
    print("_"*20)
    print (b)
    print("_"*20)
    print (c)
    print("_"*20)
    print (args)
    print("_"*20)
    print (m)
    print("_"*20)
    print (kwargs)
    print("_"*20)

func(1,2,3,4,"a","b","c","呵呵",pan ="金莲",xi = "西门")

# 1
# ____________________
# 2
# ____________________
# 3
# ____________________
# (4, 'a', 'b', 'c', '呵呵')
# ____________________
# 哈哈
# ____________________
# {'pan': '金莲', 'xi': '西门'}
# ____________________

def func(*args,**kwargs):#无敌传参，海纳百川，有容乃大
    print (args)
    print("_"*20)
    print (kwargs)

func(1,2,3,4,"a","b","c","呵呵",pan ="金莲",xi = "西门")

# (1, 2, 3, 4, 'a', 'b', 'c', '呵呵')
# ____________________
# {'pan': '金莲', 'xi': '西门'}

#实参最后一个坑
    # * 和** 在形参表示聚合
    # * 和** 在实参表示打散
lst = ["alex","傻不傻","多傻","再见"]
lst2 = ["1","2",{3:"三"},"4"]
def fun (*args):#形参 表示聚合
    print (args)
fun(*lst,*lst2)#实参（表示把lst列表打散放入函数）
# ('alex', '傻不傻', '多傻', '再见', '1', '2', {3: '三'}, '4')

# 5 、 函数的嵌套
# 模拟嵌套理解
def func1():
    print (1)
    func2()
def func2():
    print (2)
    func3()
def func3():
    print (3)
def func4():
    print (4)
    func1()

func4()
# 4 
# 1
# 2
# 3

def outer():
    print ("1")
    def inter():
        print ("2")
    print("3")
    inter()
    print ("4")
outer()
# 1
# 3
# 2
# 4

a = 10 # 全局变量
def func():
    b = 20 # 局部变量：内部的变量，外界无法直接访问
    print(locals())#查看当前作用域中内容
func()
# {'b': 20}
print (a)
# 10
print(globals())#查看全局作用域中的变量：变量，函数名，模块名，类名，对象名。。。
# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000028E5E1880B8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/py/函数/函数.py', '__cached__': None, 'a': 10, 'func': <function func at 0x0000028E5E476378>}

a = 10
def func():
    print (a)
func()
#10

# 6、global和 nonlocal
#         global 把全局变量引入到局部，可以改变全局变量的值
#         nonlocal 把局部变量引入到局部，就近原则

# 局部修改全局
a = 10
def func1():
    global a # 把全局变量引入局部（函数内部）
    a = a + 10
func1()
print(a)
# 20

a = []
def func1():
    global a # 把全局变量引入局部（函数内部）
    a = 10
func1()
print(a)
# 10

a = 10
def func1():
    a = 20
    def func2():
        nonlocal a #把局部变量引入到局部，就近原则
        a = a + 10
    func2()
    print (a)

func1()
# 30
print (a)
# 10

a =1
def func1():
    a = 2
    def func2():
        nonlocal a #把局部变量引入到局部，就近原则
        a = 3
        def func3():
            a =4
            print (a)
        print (a)
        func3()
        print (a)
    print (a)
    func2()
    print (a)
print (a)
func1()
print (a)
# 1
# 2
# 3
# 4
# 3
# 3
# 1