函数的定义

无参函数及有参函数（定参数个数）

def function_name1():
	print('记得有缩进')
    
def function_name2(a,b):
	print(a+b)

可变参数函数和关键字参数函数定义

def function_name3(*args):
	print(args)
    
>> function_name3(1)
	(1,)
>> function_name3(1,2,3,4)
	(1,2,3,4)

def function_name4(**kwargs):
	print(kwargs)
    
>> function_name4(a=1,b='asdf',c='Tom')		#传参：键值对
	{'a':1,'b':'asdf','c'='Tom'}
>> dict1 = {'d':1,'e':'asdf','f'='Tom'}
>> function_name4(**dict1)
	{'d':1,'e':'asdf','f'='Tom'}

def bb(a,b,*c,**d):
    print(a,b,c,d)
    
>> bb(1,2)				# 1 2 () {}
>> bb(1,2,3,4)			# 1 2 (3,4) {}
>> bb(1,2,x=100,y=200)	# 1 2 () {'x':100,'y':200}
>> bb(1,2,3,x=100)		# 1 2 (3,) {'x':100}

参数的默认值

def summ(a, b = 1, c = 3):
	print(a+b+c)
summ(2,4,6)			# 12
summ(2,4)			# 9
summ(2,c=4)			# 7

内部函数

a = 1
# globals()查看全局变量有哪些内容
print(globals())

def fun1():
    b = 2

    # 声明内部函数
    def inner_func():
        global a
        nonlocal b
        a -= 2
        c = 3
        b += 1
        print(a, b, c)

    # 调用内部函数
    inner_func()
    # 使用locals()查看当前函数中的内容
    print(locals())


fun1()


# 运行结果：
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x035CAF58>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/Desktop/python/pythonpractice/Test.py', '__cached__': None, 'a': 1}
-1 3 3
{'inner_func': <function fun1.<locals>.inner_func at 0x037BDDA8>, 'b': 3}

• 在内部函数中修改局部变量时，声明nonlocal，修改全局变量时，声明global；

• globals()用于查看全局变量有哪些，locals()用于查看本地变量有哪些，均以字典的形式输出。

闭包

闭包的定义

先看如下一个例子

def fun1():
    a = 2

    # 声明内部函数
    def inner_func():
        b = 8
        print(a, b)

    return inner_func

xx = fun1()
xx()

符合上述格式，将内部函数用return返回这一格式称为闭包；

符合闭包的条件：

• 外部函数中定义了内部函数
• 外部函数有返回值
• 返回的值为内部函数名
• 内部函数引用了外部函数的变量

闭包举例（计数器）

def generate_count():
    container = [0]
    
    def add_one():
        container[0] = container[0] + 1
        print('当前是第{}次访问'.format(container[0]))
        
    return add_one

counter = generate_count()

counter()	# 当前是第1次访问
counter()	# 当前是第2次访问
counter()	# 当前是第3次访问

装饰器

装饰器的特点

• 函数A以参数的形式传给函数B；
• 要有闭包的特点

以一个例子解释装饰器

# 定义一个装饰器
def decorate(func):
    a = 100
    
    def wrapper():
        func()
        print('刷漆')
        print('铺地板', a)
        
    return wrapper

# 使用装饰器
@decorate
def house():
    print('我是毛坯房')
    
    
# 调用函数house()
house()

使用装饰器，即在函数定义上加上@decorate进行使用，具体过程如下：

• 在未调用house()之前，对house()函数的定义进行装饰器装饰（house()称为被装饰函数）

  • 将house()作为参数传给装饰器decorate，开始执行decorate()并将内部函数返回

  # 若将装饰器如下定义，在加载时会进行打印操作（即不调用函数也会有输出）
  def decorate(func):
      a = 100
      print('wrapper外层打印测试')
      
      def wrapper():
          func()
          print('刷漆')
          print('铺地板', a)
          
      print('wrapper加载完成')
      return wrapper
  

  • 返回的函数地址默认由被装饰函数house()的函数名house接收

• 调用house()完成相应功能。（此时house()已是披着house的皮，完成decorate的功能）

多层装饰器

def decorate1(func):
    def wrapper(*args, **kwargs):
        func()
        print('装饰1')
    return wrapper

def decorate2(func):
    def wrapper(*args, **kwargs):
        func()
        print('装饰2')
    return wrapper


@decorate2
@decorate1
def house():
    print('我是毛坯房')
    
house()

带参数的装饰器

def outer(a):		# 第一层
    def decorate(func):		# 第二层
        def wrapper(*args, **kwargs):	# 第三层
            func(*args)
            print('----->铺地砖{}块'.format(a))
        return wrapper
    return decorate

@outer(10)
def house(time):
    print('我{}日期拿到房子的钥匙，是毛坯房'.format(time))
    
house('2020-10-16')

• 装饰器要加参数一定是三层函数嵌套
  • 第一层目的是 接受装饰器的参数
  • 第二层目的是 返回第三层的函数
  • 第三层是进行装饰

匿名函数

• 作用：简化函数定义

• 格式：lambda 参数1,参数2,... : 运算;

定义方式

s = lambda a, b: a + b
result = s(1, 3)
print(result)

匿名函数作为参数

list1 = [{'a':1,'b':35},{'a':21,'b':3},{'a':15,'b':25},{'a':13,'b':5}]
maxx = max(list1, key = lambda x: x['a'])	
#以lambda定义的方式进行最大值比较，即进行对每个键为'a'的值进行比较
print(maxx)

• map()函数

list1 = [1,4,7,9,2,6,8,0,0,2,3]
result = map(lambda x: x+2, list1)
print(list(result))

• reduce()函数（from functools import reduce）

按照自定义函数操作可迭代序列

tuple1 = (1,2,3,4,5,6,76,8)
result = reduce(lambda x, y:x+y, tuple1)
print(result)

• filter()函数

按照自定义函数进行过滤可迭代序列

list1 = [1,2,5,7,89,345,46,235,3,345,4,5]
result = filter(lambda x:x>10, list1)
print(result)

• sorted()函数

可以按照自己选取的目标进行升序排列

students = [{'name':'mark','age':14},{'name':'tom','age':16},{'name':'jonny','age':21},{'name':'danny','age':11},{'name':'jenny','age':22}]
result = sorted(students, key = lambda x: x['age'])
print(result)

• 三目运算符

func = lambda x: x if x%2 == 0 else x+1

递归函数

特点：

• 必须要有入口
• 必须要有终点