函数初识

一、函数的初识

函数是以功能为导向，函数内部尽量不要有print

def func():   #def 关键字，定义函数，空格 函数名（变量）
    # 函数体
    return 1,2,[123,2]

ret1,ret2,ret3 = func() #函数名 + （）就要执行此函数

print(ret1,ret2,ret3)

二、return 功能

1.函数里面遇到return，此函数结束，下面就不再走了,终止函数
2.return 返回值： 不写return     None
                  return        None
                  return       单个

                  return       多个  将多个值包在元组中，返回给调用者,然后打印出打印者的值

例子1
def func():
    count = 2
    l1 = []
    l1.append(count)
    return l1,2,count
ret = func()
# print(ret)     元组类型

ret1,ret2,ret3 = func()
print(ret1,ret2,ret3)

三、函数的传参

1.函数的参数分为实体参数和形式参数

def my_len(x):     #形参：形式参数
    count = 0
    for i in l1:
        count += 1
    return count
l1 =[1,2,3,4,5,6]
ret = my_len(l1)    #实参：实体参数
print(ret)

2.实参：实体参数
从实参的角度：
（1）按位置传参，必须一一对应。

例子1
def func(x):
    if len(li) > 2:
        return True
    else:
        return False
li = [1,2,3,4]
print(func(li))

例子2
def func(x,y):
    # if x > y:
    #     return x
    # else:
    #     return y
    z = x if x > y else y      #三元运算法
    return z
i = 5
j = 6
print(func(i,j))

（2）按关键字传参

def func(x,y):

    z = x if x > y else y      #三元运算法
    return z

func(y = 2,x = 3)

（3）混合传参,位置参数在前面，关键字传参在后

def func(x,y,a,b):
    print(x,y)
    print(a,b)
    return x,y,a,b
ret = func(1,2,a = 3,b = 4)
print(ret)

2.形参传参：

（1）位置传参
（2）默认参数

例题：
def func(name,sex="男"):
    with open("name_list","a",encoding = "utf-8") as f1:
        f1.write("{},{}".format(name,sex))
while 1:
    name = input("请输入名字=")
    if "xue" in name:
        sex = input("请输入性别")
        func(name,sex)
    else:
        func(name)

name = input("请输入名字")

sex =  input("请输入性别")

print(func(name))

四、函数的动态传参

1、 *args 动态参数，不定长参数

他包含了你所有的位置参数，打印出来的元素类型是是元组类型

args 需要放在位置参数前，否则会报错

例子1
args 需要放在位置参数前，否则会报错
def func(a,b,c,*args):
    print(a,b,c,*args)
func(1,2,3,4,5,6)

例子2
def func(*args):
    print(args,type(args))
func(1,2,3,4,"alex",5)

例子3
def func(*args):
    sum = 0
    for i in args:
        sum = sum + i
    return sum
print(func(1,2,3,6,78))

例子4
def func(*args):
    print(args,type(args))
func(1,2,"alex",3,4,5,6,7,8)   #(1, 2, 'alex', 3, 4, 5, 6, 7, 8) <class 'tuple'>

*args不给他传参，也不会报错，是个空元组

def func(a,b,c,*args):
    print(a)                 #1
    print(b)                 #2
    print(c)                 #alex
    print(args,type(args))   #()
func(1,2,"alex")

位置参数，*args，默认参数

def func(a, b, c,*args, sex= "nan"):
    print(a)       #1
    print(b)       #2
    print(c)       #3
    print(sex)     #女
    print(args)    #(4, 5, 6, 5, 7)
    print(a,b,c,sex,args)
func(1,2,3,4,5,6,5,7,sex = "女")

2、**kwargs()默认参数

例子1：打印出来的是字典数据类型，实参接受不定长的关键字参数

def func(**kwargs):
    print(kwargs)
func(a = 1 , b = 2, c = 3) #{'a': 1, 'b': 2, 'c': 3}

例子2：位置参数，*args，默认参数，**kwargs

def func(a,b,c,*args,sex="nan",**kwargs):
    print(a)
    print(b)
    print(c)
    print(args,type(args))       #(4, 5, 6, 5, 6, 4)    <class 'tuple'>
    print(sex)                    #nv
    print(kwargs,type(kwargs))     #{'name': 'taibai', 'name2': 'taibai2'}       #字典类型
func(1,2,3,4,5,6,5,6,4,sex = "nv",name = "taibai",name2 = "taibai2")

例子3：万能参数

def func(*args,**kwargs):
    print(args)
    print(kwargs)
func(1,2,3,4,5,name = "alex",age =15 )

3、魔法运算：打散

*args传入一个可迭代的对象就可以打散

例子1：
def func2(*args,**kwargs):
    print(args)
    print(kwargs)
l1 = [1,2,3]
l2 = [1,2,3,4,5,6,7]
func2(*l1,*l2)

例子2：*args
def func(*args,**kwargs):
    print(args,type(args))
    print(kwargs,type(kwargs))
dic1 = {"name":"alex","name1":"xue"}
dic2 = {"a":1,"b":2,"c":3}
func(*dic1,*dic2)  #('name', 'name1', 'a', 'b', 'c') <class 'tuple'>

**kwargs传入对象被打散

def func(*args,**kwargs):
    print(args,type(args))
    print(kwargs,type(kwargs))
dic1 = {"name":"alex","name1":"xue"}
dic2 = {"a":1,"b":2,"c":3}
func(**dic1,**dic2, name3 = "xue")
结果
() <class 'tuple'>
{'name': 'alex', 'name1': 'xue', 'a': 1, 'b': 2, 'c': 3, 'name3': 'xue'} <class 'dict'>

五、python的内部原理

 python代码运行的时候
 从python解释器开始执行之后，就可以在内存中开辟了一个空间，
每当遇到一个变量的时候，就把变量名和值之间对应的关系记录起来。


但是当遇到函数定义的时候，解释器只是象征性的将函数名读在内存，表示知道这个函存在了。
至于函数内部的变量和逻辑，解释器根本不关心。

等执行函数调用的时候，python解释器会再开辟一块内存储存这个函数里面的内容，
这个时候，才关注函数里面有哪些变量，而函数中的变量会储存再新开辟出来的内存中，
函数中的变量只能在函数内部使用，并且会随着函数执行完毕，这块内存的所有内容也会被清空。


“存放名字和值的关系“”  的空间 起了一个名字  命名空间
代码在运行开始，创建的存储“变量名和值的关系”的空间叫做  全局命名空间
在函数的运行中开辟的临时的空间叫做  局部命名空间

六、命名空间

命名空间：名称空间，全局名称空间，局部名称空间，内置名称空间

内置命名空间：input print sum len
加载顺序：内置名称空间---》全局名称空间 ---》局部名称空间（执行函数时）
取值顺序：局部空间找---》全局名称空间---》内置名称空间找

例子1：
name = "wusir"
def func():
    name = "alex"
    print(name)   #alex
func()

例子2：
name = 1
def func():
    n = 2
    print(666)   #NameError: name 'n' is not defined
print(n)

例子3：return后面是什么就返回什么
def len(x):
    return x
print(len([1,2,3]))    #[1, 2, 3]

七、作用域

作用域就是作用范围，按照生效范围可以分为全局作用域和局部作用域
全局作用域：全局名称空间，内置名称空间。在整个文件的任意位置都能被引用、全局有效
局部作用域：局部名称空间，只能在局部范围内生效

name = "wusir"
print(globals())
def func():
    name = "alex"
    # print(globals())
    print(locals())     #{'name': 'alex'}
func()

def func1():
    print(222)
    def func2():
        print(111)
func1()    #222
func2()    #name 'func2' is not defined


例子2：
def func1():
    print(111)
def func2():
    print(222)
    def func3():
        print(444)
func2()   #222

例子3：
print(111)
def func2():
    print(222)
    def func3():
        print(666)
    print(444)
    func3()
    print(888)
print(333)
func2()
print(555)

八、global：

1.声明一个全局变量
2.在局部作用域想要对全局作用域的全局变量进行修改时，需要global（限于字符串、数字）

在局部作用域，对全局变量进行修改

def func():
    global a
    a = 3
func()
print(a)    # 3

例子2
count = 1
def search():
    global count
    count = 2
search()
print(count)   #2

对可变数据类型（list，dict，set）可以直接引用不用通过global

l1 = [1,2,3]
def func():
    l1.append(444)
func()
print(l1)     #[1, 2, 3, 444]

九、nonlocal:

1.不能修改全局变量
2.在局部作用域中，对父级作用域（或者更外层作用域非全局作用域）的变量进行引用和修改，并且引用的那层，
从那层及以下此变量全部发生改变。

例子1
def add_b():
    b = 42
    def do_global():
        b = 10
        print(b)
        def dd_nonlocal():
            nonlocal b
            b = b + 20
            print(b)
        dd_nonlocal()
        print(b)
    do_global()
    print(b)
add_b()

例子2：

a = 1
def func():
    nonlocal a
    a = 2
    print(a)
func()   #SyntaxError: no binding for nonlocal 'a' found


例子2:
def func():
    name = "wusir"
    def inner():
        nonlocal name
        name = "taibai"
        print(name)
    inner()
    print(name)
func()

十、补充知识：

陷阱参数

def func(name,l = []):
    l.append(name)
    return l
print(func("alex"))  #['alex']
print(func("wusir")) #多次调用函数，保存了上次的值 #['alex', 'wusir']