函数1

Date: 2019-05-27

Author: Sun

1.函数定义

​ 函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

​ 函数能提高应用的模块性，和代码的重复利用率。Python提供了许多内建函数，比如print()。也可以自己创建函数，这被叫做用户自定义函数。

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

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）一般来说，函数传递参数个数在5个以内，则可以考虑采用传递固定参数方式

  ​ （2）如果传递的参数是一个整体信息，怎么办？类 ---- 可以考虑传递类的实例对象

  问题？

  ​ 如果函数要传递的参数个数很多怎么办，比如每次传递个数不定，如何是好？

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

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

2.3 参数组合

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

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)
  

判断一个函数返回值

#判断是否能被2整除  传入函数
def even(n):
    return n % 2 == 0

#能被3整除 传入函数
def divid_by3(n):
    return n % 3 == 0

5 文档字符串

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

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

文档字符串书写规则：

• 必须在函数的首行

• 使用三引号注解的多行字符串(''' ''') 或(""" """)

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

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

6.参数传递

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

• 不可变对象：int、float、None、complex、bool、tuple、str
• 可变对象: dict、list

7 空函数

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

def test():
    pass

8 匿名函数

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

特点：

• lambda只是一个表达式，函数体比def简单的多
• lambda的函数体不再是代码块
• lambda只有一行，增加运行效率

语法：

lambda [arg1,arg2....argn]:函数体
add = lambda a,b:a + b
print(add(3,5))

9.函数类型

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

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

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

10.传入函数

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

#通用求和函数
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))

偏函数

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

# -*- coding: utf-8 -*-
__author__ = 'sun'
__date__ = '2019/5/27 9:54'

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) #需要使用关键字参数，否则会报错

递归函数(难点)

1 嵌套调用

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

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

3 递归调用过程

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

4 递归适用条件

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

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

递归的写法：

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

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