python函数，了解这些就够了

函数是python中的重点，也是面向对象的一个基础，下面对python中的函数内容做了一个总结，有问题欢迎指出。

一.函数基础

1.1-基础概念

（1）基本语法

def 函数名(参数列表):

	函数体(代码块)

	return 返回值

（2）函数调用 判断函数是否可调用 callable

def add(x,y):
    result = x + y
    return result
callable(add) #存在add函数，返回True，否则返回False

>>> True

---

1.2-传参

(1) 位置传参 & 关键字传参

​ 设def add(x,y):

​ 位置传参：add(4,5) , 关键字传参：add(x=4, y=5)

​ 缺省值 （形参的默认值）

​ 如：def add(x = 5,y) 传参时，不给X赋值，则X = 5，若赋值则为赋的值

(2) keyword-only

只能用关键字传参(可先了解下面的不定长传参)

#前面两个数传给x,y后面的数传给agrs并封装成数组
def test(x, y ,*agrs): 
    print(x, y, agrs)
test(1,2,3,4,5,6,7,8)

>>> 1 2 (3, 4, 5, 6, 7, 8)

# ---------------------------------------------------------
# keyword-only   x,y 只能用关键字传参，否则数据全部被agrs接收
def f(*agrs,x,y): 
    print(agrs,x,y)
f(5,8,6,9,6,x=2,y=6)

>>> (5, 8, 6, 9, 6) 2 6

(3) 不定长传参

• 不定长位置传参

def f(*agrs):
    sum = 0
    for i in agrs: # for能遍历agrs，*agrs把元素封装成元组
        sum += i 
    return sum
f(1,2,3)

>>> 6
# ------------------------------------------------------------------------
def k(*agrs):
    print(agrs)
k(1,2,3,4,5,6)  #封装成tuple

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

• 不定长关键字传参

def f(**agrs):
    print(agrs)
f(a=123,b=456,c=789) #封装成dict

>>> {'a': 123, 'b': 456, 'c': 789}

---

1.3-参数解构

#列表解构
def f(*agrs):
    print(agrs)
f([1,2,3,4,5,6]) #未解构只有一个元素
>>> ([1, 2, 3, 4, 5, 6],)

f(*[1,2,3,4,5,6]) # 解构后多个元素
>>> (1, 2, 3, 4, 5, 6)

# -------------------------------------------------------------------------
# 字典解构
def add(x,y):
    print(x,y)
    return x+y
add(**{'x':1,'y':2})

>>> 1 2
>>> 3

---

---

二.作用域

函数中变量的作用域

2.1-全局变量和局部变量

TIP：函数是一个封装，它会开辟一个作用域，x变量被限制在作用域中，在函数外部x 变量不可见( 外面定义的变量内可见，内部定义的外部不可见 )

x = 100  # 这里的x为全局变量
def f():
    print(x) #外部定义内可见
f()

>>> 100

# -------------------------------------------------------------------------
x = 100  # 这里的x为全局变量
def f():
    x += 100 # x = x + 100,理解为 x(局部2) = x(局部1) + 100，但局部1没定义初始值
    print(x) 
f()

>>> UnboundLocalError: local variable 'x' referenced before assignment

2.2-global

当前函数中的变量，用全局变量

x = 100 # 全局变量
def f():
    global x #函数中局部变量x，用全局变量x替代
    x += 100
    print(x)
f()

>>> 200

2.3-nonlocal

非当前函数的局部变量， 可以是外层函数的局部变量，但不可是global

def outer():
    a = 100
    def inner():
        nonlocal a #非当前函数的局部变量，但可是外层函数的局部变量，不能是global
        a += 100
        print(a)
    return inner
m = outer()
m()

>>> 200

---

---

三.装饰器

3.1-闭包

(1) 形成闭包的条件

• 必须有个内嵌函数

• 内嵌函数引用外部函数的变量

• 外部函数的返回值是内部函数

def outer():
    x = 123
    print('调用了outer')
    def inner():
        print(x)
        print('调用了inner')
    return inner
res = outer()
res()
>>>:
调用了outer
123
调用了inner

---

3.2-装饰器

(1) 普通装饰器

def decor(func):
    def inner():
        print('222')
        func()
        print('333')
    return inner

def love():
    print('111')  
love = decor(love)

执行>>>love()
out>>>222
      111
      333

# 过程 ： dector(love)调用dector函数，返回的是inner函数对象，赋值给了新的love，
# 执行love（），相当于执行了inner（）

(2) 装饰器装饰多函数

装饰器装饰不同函数，并得到不同内容 视频

# 装饰器装饰不同函数，并且内容不一样
def outer(arg):
    def decor(func):
        def inner():
            if arg == 'xiao':
                print('笑得真开心')
                func()
            elif arg == 'ku':
                print('节哀')
                func()
        return inner
    return decor

# 函数（‘xiao’） >> 装饰器 （装饰器是一个函数，即 调用 函数1 得到 函数2 ）
@outer('xiao')
def smile():
    print('开心')

@outer('ku')
def cry():
    print('悲伤')

(3) 装饰器调用类

class face:
    def smile():
        print('hahha')
    
def outer(cls):   
    def decor(func):
        def inner():   
            func()
            cls.smile()
        return inner
    return decor

@outer(face)
def cry():
    print('wuwuwu')

(4) 基本函数带参装饰器

#基本函数含参数的装饰器
def decor(func):
    def inner(*p, **w):
        print('222')
        func(*p, **w)
        print('333')
    return inner

@decor #love = decor(love)
def love(*person, **child):
    print(person,child)
love('father','mather',son='tom',dau='jarry')

>>>:
222
('father', 'mather') {'son': 'tom', 'dau': 'jarry'}
333