1、python函数

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

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

2、函数分类

1、内置函数

2、自定义函数

3、为什么要定义函数

函数即变量，变量必须先定义后使用，未定义而直接引用函数，就相当于在引用一个不存在的变量名
代码演示？

4、定义一个函数

你可以定义一个由自己想要功能的函数，以下是简单的规则：

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

5、自定义函数主要做什么

只检测语法，不执行代码

6、定义函数的三种形式

无参：应用场景仅仅只是执行一些操作，比如与用户交互，打印
有参：需要根据外部传进来的参数，才能执行相应的逻辑，比如统计长度，求最大值最小值
空函数：设计代码结构

7、函数的调用

定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行。

如下实例调用了 printme() 函数：

    1 先找到名字
    2 根据名字调用代码
　　
　　函数的返回值？
　　0->None
　　1->返回1个值
　　多个->元组

　　什么时候该有？
　　　　调用函数，经过一系列的操作，最后要拿到一个明确的结果，则必须要有返回值
　　　　通常有参函数需要有返回值，输入参数，经过计算，得到一个最终的结果
　　什么时候不需要有？
　　　　调用函数，仅仅只是执行一系列的操作，最后不需要得到什么结果，则无需有返回值
　　　　通常无参函数不需要有返回值

8、函数调用的三种形式

1 语句形式：foo()
2 表达式形式：3*len('hello')
4 当中另外一个函数的参数：range(len('hello'))

9、函数的参数

1 形参和实参定义
2 形参即变量名，实参即变量值，函数调用则将值绑定到名字上，函数调用结束，解除绑定
3 具体应用
　　位置参数：按照从左到右的顺序定义的参数
　　　　位置形参：必选参数
　　　　位置实参：按照位置给形参传值

　　关键字参数：按照key=value的形式定义实参
　　　　无需按照位置为形参传值
　　　　注意的问题：
　　　　　　1. 关键字实参必须在位置实参右面
　　　　　　2. 对同一个形参不能重复传值

　　默认参数：形参在定义时就已经为其赋值
　　　　可以传值也可以不传值，经常需要变得参数定义成位置形参，变化较小的参数定义成默认参数（形参）
　　　　注意的问题：
　　　　　　1. 只在定义时赋值一次
　　　　　　2. 默认参数的定义应该在位置形参右面
　　　　　　3. 默认参数通常应该定义成不可变类型

　　可变长参数：
　　　　针对实参在定义时长度不固定的情况，应该从形参的角度找到可以接收可变长实参的方案，这就是可变长参数（形参）

　　　　而实参有按位置和按关键字两种形式定义，针对这两种形式的可变长，形参也应该有两种解决方案，分别是*args，**kwargs

        ===========*args===========

        def foo(x,y,*args):

            print(x,y)

            print(args)

        foo(1,2,3,4,5)

        def foo(x,y,*args):

            print(x,y)

            print(args)

        foo(1,2,*[3,4,5])

        def foo(x,y,z):

            print(x,y,z)

        foo(*[1,2,3])

        ===========**kwargs===========

        def foo(x,y,**kwargs):

            print(x,y)

            print(kwargs)

        foo(1,y=2,a=1,b=2,c=3)

        def foo(x,y,**kwargs):

            print(x,y)

            print(kwargs)

        foo(1,y=2,**{'a':1,'b':2,'c':3})

        def foo(x,y,z):

            print(x,y,z)

        foo(**{'z':1,'x':2,'y':3})

        ===========*args+**kwargs===========

        def foo(x,y):

            print(x,y)

        def wrapper(*args,**kwargs):

            print('====>')

            foo(*args,**kwargs)

　　命名关键字参数：*后定义的参数，必须被传值（有默认值的除外），且必须按照关键字实参的形式传递
　　　　可以保证，传入的参数中一定包含某些关键字

        def foo(x,y,*args,a=1,b,**kwargs):

            print(x,y)

            print(args)

            print(a)

            print(b)

            print(kwargs)

        foo(1,2,3,4,5,b=3,c=4,d=5)

        结果：

            1

            2

            (3, 4, 5)

            1

            3

            {'c': 4, 'd': 5}

10、函数对象：函数是第一类对象，即函数可以当作数据传递

1 可以被引用
2 可以当作参数传递
3 返回值可以是函数
3 可以当作容器类型的元素

#利用该特性，优雅的取代多分支的if

def foo():

    print('foo')

def bar():

    print('bar')

dic={

    'foo':foo,

    'bar':bar,

}

while True:

    choice=input('>>: ').strip()

    if choice in dic:

        dic[choice]()

11、函数的嵌套　　

11.1 函数的嵌套调用

def max(x,y):

    return x if x > y else y

def max4(a,b,c,d):

    res1=max(a,b)

    res2=max(res1,c)

    res3=max(res2,d)

    return res3

print(max4(1,2,3,4))

11.2函数的嵌套定义

def f1():

    def f2():

        def f3():

            print('from f3')

        f3()

    f2()

f1()

f3() #报错

巴特西

第三篇：python函数