python——函数

python——函数

函数是什么

函数一词来源于数学，但编程中的「函数」概念，与数学中的函数是有很大不同的，编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做subroutine(子过程或子程序)，在Pascal中叫做procedure(过程)和function，在C中只有function，在Java里面叫做method。

在python中函数它相当于一个独立的代码块，可以被重复使用，如果需要增加一个功能或者修改一个功能，只需要，增加或者修改函数即可。

函数分类

内置函数

python解释器已经为我们定义好的参数，比如:len(),sum(),max()等

函数的定义

列子：定义函数使用def关键字，后面是函数名，函数名不能重复

def fun():#定义一个函数，后面是函数名
    print("Hello World")#函数体
我们看一下实列

def 函数名(参数1，参数2，参数3,....):
      '''注释名'''
      函数体
      return 返回的值

一旦执行到return，整个函数就结束了。如果没有return，会默认返回None。return可以返回多个参数，这多个参数用元组封装。

函数的参数

1.形参和实参

函数在调用的时候，可以传入参数，有形参和实参，简单点说，形参就是函数接收的参数，而实参就是你实际传入的参数。
形参：形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。
实参：实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。函数调用结束返回主调用函数后则不能再使用该形参变量。

形参，实参如下：

#1、位置参数：按照从左到右的顺序定义的参数
        位置形参：必选参数
        位置实参：按照位置给形参传值

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

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


#4、可变长参数：
        可变长指的是实参值的个数不固定
        而实参有按位置和按关键字两种形式定义，针对这两种形式的可变长，形参对应有两种解决方案来完整地存放它们，分别是*args，**kwargs

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

def foo(x, y, *args):
    print(x, y)     # 1 2
    print(args)     # (3, 4, 5)

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

-----------------------------------------------
def foo(x, y, *args):
    print(x, y)     # 1 2
    print(args)     # (3, 4, 5)

foo(1, 2, *[3, 4, 5])
-----------------------------------------------
def foo(x, y, z):
    print(x, y, z)      # 1 2 3

foo(*[1, 2, 3])

-----------------------------------------------
def foo(*args, x, y):
    print(x, y)     
    print(args)
    
foo(1, 2, *[3, 4, 5])       # 报错



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

def foo(x, y, **kwargs):
    print(x, y)         # 1 2
    print(kwargs)       # {'c': 3, 'a': 1, 'b': 2}

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

----------------------------------------------
def foo(x, y, **kwargs):
    print(x, y)         # 1 2
    print(kwargs)       # {'c': 3, 'a': 1, 'b': 2}

foo(1, y=2, **{'a': 1, 'b': 2, 'c': 3})
-----------------------------------------------
def foo(x, y, z):
    print(x, y, z)      # 2 3 1

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

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

def foo(x, y, *args, **kwargs):
    print(x, y)         # 1 2
    print(args)         # (3, 4, 5)
    print(kwargs)       # {'c': 4, 'b': 3, 'd': 5}

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

----------------------------------------------
*后定义的参数，必须被传值（有默认值的除外），且必须按照关键字实参的形式传递
def foo(x, y, *args, a=1, b, **kwargs):
    print(x, y)         # 1 2
    print(args)         # (3, 4, 5)
    print(a)            # 1
    print(b)            # 3
    print(kwargs)       # {'c': 4, 'd': 5}

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

2.默认参数

默认参数就是在定义形参的时候，给函数默认赋一个值，比如说数据库的端口这样的，默认给它一个值，这样就算你在调用的时候没传入这个参数，它也是有值的

# port=3306为默认值参数
def connect(ip,port=3306):
    print(ip,port)

#如果给一个port值，则传新给的值
connect('118.1.1.1',3307)
#如果不填，则使用默认参数
connect('118.1.1.1')

使用函数

使用的原则

函数使用的时候，要保证先定义，后调用

例子如下：

函数即“变量”，“变量”必须先定义后引用。未定义而直接引用函数，就相当于在引用一个不存在的变量名
#测试一
def foo():
    print('from foo')
    bar()
foo() #报错

#测试二
def bar():
    print('from bar')
def foo():
    print('from foo')
    bar()
foo() #正常

#测试三
def foo():
    print('from foo')
    bar()
    
def bar():
    print('from bar')
foo() #会报错吗?


#结论:函数的使用,必须遵循原则:先定义,后调用
#我们在使用函数时,一定要明确地区分定义阶段和调用阶段

#定义阶段
def foo():
    print('from foo')
    bar()
def bar():
    print('from bar')
#调用阶段
foo()

调用函数方式

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

嵌套函数
嵌套函数说直接点就是在函数还有另一个函数
函数嵌套还分为调用和定义
我们先看一下调用：

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))

接下来我们看一下嵌套函数的定义：

def f1():
            print('from f3')
f1()

 函数的特性

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

比如：

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

def demo():
    print("demo1")
a = demo
b = a
b()