Python函数

一、函数引入

前面我们写过九九乘法表，但如果我要七七乘法表或五五乘法表的话，你会看到三者代码极其类似，只是循环变量不同，那么如何做到代码重用，而不是简单拷贝黏贴修改呢，其实可是使用函数完成这一功能

def table(row,col,sep=3):
    for i in range(1, row + 1):
        for j in range(1, col + 1):
            if j <= i:
                print("%d*%d = %2d" % (i, j, i * j), end='%*s'%(sep,' '))
        print('')
#一次编码，到处运行
table(8,8)
table(5,5,8)

函数的优点：

• 代码可复用
• 代码可维护性高
• 容易排错
• 可读性好
• 利于团队开发

1.函数定义

函数就是完成特定功能的代码块，本质上是对代码的封装。 语法格式

def 函数名（[参数1],[参数2]....[参数n]）:
	函数体

• 函数名命名规则同变量名，要满足标识符命名规则
• 不能和系统函数重名，否则系统函数无法使用
• 函数定义分两部分函数头和函数体
• 函数体，就是实现功能的代码段，以：开头，必须缩进
• 函数名的命名风格：一般建议用下划线分隔的小写单词组成：say_hello

2 函数参数

2.1 实参和形参

• 形参：就是函数定义时小括号里的变量
• 实参：函数调用的时候，小括号里的表达式
• 函数可以没有形参和实参

2.2 参数分类

• 位置参数，要求实参顺序必须和形参顺序完全一致，由形参顺序决定实参顺序

  def say_hello(name,age,home):
      print('大家好，我是{},我今年{}岁了，我来自{}'.format(name,age,home))
  
  say_hello('王二妮',18,'湖北武汉') #实参个数、顺序必须和形参一致
  

• 关键字参数，函数调用时，实参可以是键值对，键就是形参名字，这样的调用，实参不必关心形参的顺序。

  def say_hello(name,age,home):
      print('大家好，我是{},我今年{}岁了，我来自{}'.format(name,age,home))
  
  say_hello(name='王二傻',home='大连',age=20)  #三个关键字参数
  say_hello('大傻',home='美国',age=30)  #两个关键字参数
  sya_hello('二傻',24,home='何方')    #一个关键字参数
  

• 默认值，如果形参在定义的时候给定一个值，那么函数在调用时就可以不传实参，可以简化调用

  • 默认值参数必须放到最右边
  • 如果传了实参，那么实参优先，不会使用默认值
  • 默认值只计算一次
  • 默认值必须是不可变对象

  def my_power(x,n=2):
  	return (x) ** n
  my_power(3)
  my_power(4,0.5)
  
  def test(a=[]):
      a.append('end')
      print(a)
  test([1,2,3])
  test()   #['end']
  test()   #['end','end']
  

• 可变参数，传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。

  #使用*接收任意数量的位置参数
   #注意：*的不定长参数被当做元组处理
  def demo(a,b,*args):
      print(a,b,args)
  
  demo(12,33,90)
  demo(1,2,3,4,5)
  a=(1,2,3)
  demo(*a)
  
  #使用**接收任意数量的关键字参数
  #注意:**的不定长参数被当做字典处理
  def demo1(a,**args):
      print(a,args)
  demo1(1,name='kk',age=3)
  b = {'a':20,'b':12,'c':32}
  demo(**b)
  

2.3 参数组合

• 形参顺序须按照以下顺序：位置参数、默认值参数、*args,**kwargs

3 函数调用

• 函数调用必须在函数定义之后

• 函数调用必须能够正确传递实参

  def demo(a,b,c=0,*arg1,**arg2):
  	print(a,b,c,arg1,arg2)
  demo(1,3,k=4)
  demo(1,2,3,4,5)
  demo(1,b=3,c=3,d=5)
  demo(*(1,2,3),**{'name':12})  #任何函数都可通过这种形式传递参数
  

4 返回值

可以通过return语句返回计算结果。语法： return 表达式

• return的作用一个是终止函数的执行，所有执行了return后，其后的语句不会被执行

• 如果没有return语句，则默认返回的是None

• return还可以返回给调用者数值

• return可以返回一个值，如果要返回多个值，那么返回的是一个元组

  def demo2():
      return 1
  def demo3():
      return 1,2,3
  print(demo2())
  print(demo3())  #(1,2,3)
  

5 文档字符串

函数文档字符串documentation string （docstring）是在函数开头，用来解释其接口的字符串。简而言之：帮助文档

• 包含函数的基础信息
• 包含函数的功能简介
• 包含每个形参的类型，使用等信息

文档字符串书写规则：

• 必须在函数的首行

• 使用三引号注解的多行字符串(’’’ ‘’’) 或(""" “”")

• 函数文档的第一行一般概述函数的主要功能，第二行空，第三行详细描述。

  def test():
      """
          函数名：test
          功能：测试
          参数：无
          返回值：无
      """
      print("函数输出成功")
  
  #使用__doc__属性查看文档字符串
  print(test.__doc__)
  

6.参数传递

python的参数传递是简单的值传递，当然这里的值是指变量的引用（地址），不是变量的值。不存在值传递和引用传递的区分。简而言之，python的参数传递可以称之为对象引用传递，对象可以分为：

• 不可变对象：int、float、None、complex、bool、tuple、str,range
  • 在函数内部不可能修改函数外部的变量
• 可变对象: dict、list
  • 可以在函数内部修改

7 空函数

借助于pass语句实现，函数体不完成任何功能，只有一个pass语句

def test():
    pass

8.函数类型

函数也是一种类型，我们自定义的函数就是函数对象，函数名保存了函数对象的引用（地址）

def test():
    print('我是测试函数')

print(test)  #函数名是变量，指向了函数对象
pf = test    #pf变量也指向了函数对象，所以也可以通过pf调用test函数
pf()

9. 匿名函数

不再使用def 函数名()这种形式定义函数，而是使用lambda来创建匿名函数

特点：

• lambda只是一个表达式，函数体比def定义的函数简单的多
• lambda的函数体不再是代码块,而是一个表达式
• lambda只有一行，运行效率很高

语法：

lambda [arg1,arg2....argn]:表达式
add = lambda a,b:a + b
print(add(3,5))

10.传入函数

一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数，也可以称之为传入函数。可以实现通用编程，排序等复杂功能

#传入函数,高阶函数
#能被2整除数的和
def sum_even(n):
    sum = 0
    for i in range(1,n+1):
        if i % 2 == 0:
            sum += i
    return sum

#能被7整除的数的和
def sum_seven(n):
    sum = 0
    for i in range(1,n+1):
        if i % 7 == 0:
            sum += i
    return sum
#能被3和5整除，但不能7整除的数的和
def sum_fifteen(n):
    sum = 0
    for i in range(1,n+1):
        if i % 15 == 0 and i % 7 != 0:
            sum += i
    return sum
#通用求和函数
def sum1(n,callback):
    '''
    功能：求满足callback规定条件的数的和
    :param n: 大于0的整数
    :param callback: 用于判断一个数是否满足指定条件，由调用者传入,有一个参数，形如：def callback(n)
    :return: 求和的结果
    '''
    sum = 0
    for i in range(1,n+1):
        if callback(i):
            sum += i
    return sum
print(sum1(100,lambda x:x%2==0))
print(sum1(100,lambda x:x%7==0))
print(sum1(100,lambda x:x%15==0 and x % 7 != 0))

11.闭包

我们可以在一个函数中再定义一个函数，在函数内部定义的函数称之为***内部函数***，内部函数只能在函数内使用，不会污染外部空间。定义内部函数的函数称之为***外部函数***，这样的定义构成函数的嵌套

def outter(a): #外部函数
    x = 10
    def inner(y):  #内部函数
        print(x + y)
    inner(a)
    
outter(20)

• 内部函数只能在外部函数里调用，外界无法直接调用内部函数

在一个外部函数中定义了一个内部函数，内部函数里引用了外部函数的变量，并且外部函数的返回值是内函数的引用。这样内部函数和其执行所需的环境变量就构成了一个***闭包***。

一般情况下，如果一个函数结束，函数的内部所有东西都会释放掉，局部变量都会消失。但是闭包是一种特殊情况，如果外函数在结束的时候发现有自己的局部变量将来会在内部函数中用到，就把这个局部变量绑定给了内部函数，然后自己再结束。

def outter(a): #外部函数
    x = a
    def inner(y):  #内部函数
        return x + y  #引用外部变量
    return inner  #返回内部函数（闭包）
pf = outter(20)
print(pf(10))  #30
print(pf(20))  #40

在闭包中无法直接修改外部变量x的值

def outter(a): #外部函数
    x = a
    def inner(y):  #内部函数
       # x += 10   #UnboundLocalError: local variable 'x' referenced before assignment
        return x + y
    return inner

在python3中可以通过nonlocal关键字声明一下x，表示这个变量不是局部变量，需要向上一层变量空间找这个变量。

def outter(a): #外部函数
    x = a
    def inner(y):  #内部函数
        nonlocal x
        x += 10
        return x + y
    return inner

12.偏函数

当一个函数有大量参数，调用的时候非常不方便，可以使用偏函数技术，将一些参数固定（给默认值），达到简化函数调用的目的。

import functools
def test(a,b,c,d):
    print(a, b, c, d)
#从前面固定参数，使用位置参数就行，1=>a，2=>b
test1 = functools.partial(test,1,2)
test1(3,4)  #3=>c  4=>d

#从后面固定参数，需要使用关键字参数
test2 = functools.partial(test,c=3,d=4)
test2(1,2)  #1=>a 2=>b

#如果固定的参数不连续，则需使用关键字参数固定
test3 = functools.partial(test,b=2,d=4)
test3(a=1,c=3) #需要使用关键字参数，否则会报错

13.变量的作用域

程序中的变量并不是在任意的位置都可以随意访问，在哪里可以访问取决于这个变量的作用域，变量的作用域指的是变量在那段代码中可以使用，可以使用变量的那段代码就是变量的作用域。在python中，只有函数/类/模块才引入作用域，if/elif/else , while/for,try/except等并不会引入新的作用域

#if语句不引入新作用域，msg在外面可以使用
if True:
    msg = "message"

print(msg)

13.1 变量作用域的分类

按照作用域划分，可以分为：

• L：Local，局部作用域
• E：Enclosing，闭包作用域【闭包的外部函数中定义的变量】
• G：Global，全局作用域 在所有函数外定义的变量
• B：Built-in，內建作用域【内置作用域】

#局部作用域  
#局部变量只能在函数内部使用，外部无法引用
#局部变量的作用域从定义开始到函数体结束
def demo():
    num = 20  #局部变量  
    print(num)
demo()
#print(num) 错误

#闭包作用域
def outter():
   x = 10   #函数作用域,从定义开始到本函数结束
   def inner():
      y = x  #在闭包中可以引用
      print(y)
   return inner
pf = outter()
pf()  #执行闭包
print(pf.__closure__)

#全局作用域
x = 100    #全局作用域  从定义开始到本文件结束
def demo():
   print(x)
print(x)

#内建作用域，是指系统内建的函数或常量，在系统载入时加载，在所有模块中都可以直接引用
#比如说系统函数
print(max(1,2,3))  #max函数就是内建作用域  哪里都可以引用
def  demo():
    x = 30
    y = 50
    print(max(x, y))

13.2 变量作用域查找规则

以 L --> E --> G -->B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，最后到内建作用域中找。

13.3 全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，被称为局部变量

定义在函数外面的变量拥有一个全局作用域，被称为全局变量

局部变量和全局变量同名，局部优先

total = 0   #全局变量
def sum(arg1,arg2):
    total = arg1 + arg2   #局部变量
    print("函数内部：",total)
    return total
    
sum(10,20)
#print(total1)
print("函数外部：",total)

num = 1
def fun1():
    print(num) #UnboundLocalError: local variable 'num' referenced before assignment
    num = 123
    print(num)

fun1()

13.4 global和nonlocal

#1.在Python中，当内部作用域想修改全局变量的时候，则就要使用global关键字进行声明
num = 1
def fun1():
    global num   #告诉编译器，此处的num是全局变量
    print(num)   #1
    num = 123
    print(num)  #123
    
fun1()

a = 10
def test():
    global  a
    a = a + 1
    print(a)
test()

#2.如果要修改函数作用域中的变量，则使用nonlocal
#需要明确的是，nonlocal关键字定义在闭包里面
x = 0  #全局作用域

def outer():
    x = 1   #闭包作用域

    def inner():
        nonlocal x
        x = 2   #局部作用域
        print("inner:",x)  #2

    inner()
    print("outer：",x)  #1---->2

outer()
print("全局：",x)  #0

#nonlocal关键字：声明了该变量不只是在outer函数中有效,在inner函数内部也有效

14. 装饰器(重点，难点)

软件开发中有一条非常重要的规则就是：对修改封闭，对扩展开放。
对于一个现有的函数，如果想要增强此函数的功能，但是不允许修改此函数源代码的时候，使用装饰器来解决这个问题

• 本质：就是一个闭包，还是一个返回函数的高阶函数

• 好处：就是在不用修改原函数代码的前提下给函数增加新的功能

14.1 装饰器写法

#被修饰的函数
def say_hello(name):
	print('我就是人见人爱，花见花开的%s'%name)
	
# 参数是被修饰函数
def wrapper(func):     #1.定义装饰器
    def inner(name):   #2.定义闭包 在闭包中增加功能
        print('-' * 50)
        func(name)     #3.调用原函数实现原来的功能
        print('*' * 50)
    return inner       #4.返回增强功能的函数

say_hello = wrapper(say_hello) #5.获取增强功能的函数
say_hello('风流小王子')         #6. 调用增强函数，实现功能

14.2使用@语法糖将装饰器应用到指定函数上，简化使用

#用法：在需要被装饰的函数前面加上:  @装饰器的名字  【外层函数的名字】
def wrapper(func):
  def inner(age1):
      #增加的功能
      if age1 < 0:
          age1 = 0
      #调用原函数
      func(age1)
  return inner
  
@wrapper     #相当于 getAge = wrapper(getage)
def getAge(age):
	print(age)
getAge(18)  #调用增强的函数
注意：使用@的时候，如果装饰器和需要被装饰的函数在同一个.py文件中的时候，装饰器一定要出现在被装饰函数的前面【Python中的代码是从上往下依次执行的】

14.3 带有不定长参数的装饰器

同一个装饰器可以应用于多个函数

def wrapper(func):       
  def inner(*tup,**kw):  #变长参数
      func(*tup,**kw)  
      print('-'*50)    
  return inner    
  
@wrapper                 
def test1(a,b):    
	print(a,b)  
test1(1,2)       

@wrapper                 
def test1(a):        
      print(a)   

14.4 多个装饰器作用在一个函数上(不重要)

#多个装饰器同时作用于一个函数的时候，要注意一下装饰器执行顺序
	def wrapper1(func):
	  print("wrapper1~~~~外部函数")
	  def inner(a,b):
	      print('wrapper1-----内部函数')
	      func(a,b)
	  return inner
	
	def wrapper2(func):
	 	print("wrapper2~~~~外部函数")
	    def inner(a, b):
	        print("wrapper2~~~~内部函数")
	        func(a, b)
	    return inner
	    
	@wrapper1
	@wrapper2
	def text(num1,num2):
		print(num1 + num2)	
		
	text(10,20)

15.递归函数

15.1 嵌套调用

在函数A中可以调用函数B，在函数B中可以调用函数C，这种调用方式称为函数的嵌套调用。

15.2 递归调用

一个函数直接或间接的调用自己则称为递归调用。

def fac(n):
      if n ==0:  #递归终止条件，如果n为0，则结束递归调用，返回
          return 1
      else:
          tmp = fac(n-1)  #调用自己计算n-1的阶乘
          return n * tmp #返回n * (n-1)!
    print(factorial(5))  #120

15.3 递归调用过程

递归调用可分解为两个过程，正向递归调用和逆向递归返回。

15.4 递归适用条件

如果一个问题规模缩减后，求解方式和原来一样，小规模问题解决后导致问题的最终解决，则可适用递归

• 形式是递归的 阶乘和斐波那契数列
• 结构是递归的 列表遍历
• 解法是递归的 汉诺塔

递归的写法：

• 一个递归程序必须包含两部分：
  • 1） 递归终止条件
  • 2） 递归调用自己

def  recurve(*args,**kw):	
      if 递归终止条件:   #递归终止条件必须在递归调用前
          # to do 
       else:
          #to do
          recurve(参数)
          #to do