函数基础

在python的学习过程当中，我们肯定会知道我们在编程的过程当中肯定会使用大量的代码来实现我们想要达到的功能，但是大量的代码的编写肯定会让我们的工作量大大增加，这就需要一种工具来帮助简化这些流程，而在python当中函数就是最重要的工具。

如果不使用函数我们可能会遇到的问题：

1、代码量大，代码组织不清晰，可读性差

2、遇到重复的功能只能重复编写代码，代码r冗余

3、功能需要扩展的时候，需要找出所有实现该功能的地方来修改，无法统一管理且维护难度极大

1、函数分类

1、内置函数

为了方便我们的开发，针对一些简单的功能，python解释器已经为我们定义好了的函数即内置函数。对于内置函数，我们可以拿来就用而无需事先定义，如len(),sum(),max()

2、自定义函数

内置函数所能提供的功能是有限的，这就需要我们自己根据需求，事先定制好我们自己的函数来实现某种功能，以后，在遇到应用场景时，调用自定义的函数即可

2、定义函数

对于python当中的一些内置函数我们之间有一些简单的接触，但是对于自定义函数却是没有了解过。随着我们对于程序的各种需求自定义函数的应用会更加广泛

2.1、语法

del  函数名（参数1，参数2，...）
      '''
   文档描述
      '''
    函数体
   return  返回值

函数名：函数名是用来调用函数的，函数名的命名必须能反映出函数的功能

文档描述：推荐在定义完函数之后写，可以增强函数的可读性

return：函数执行后返回的值

2.2、使用原则

1、先定义，再调用

函数和我们之前所了解的变量很相似，用老师的一句话说就是“函数即变量”，所有函数只能定义之后才可以执行，如果没有定义就执行的话就相当于在应用一个不存在的变量名。

del   foo（）
     print（from  foo）
     bar（）
foo（）
#其中bar（）没有定义无法执行
del  foo（）
      print（from foo）
 del  bar（）
       print（from bar）
foo（）
#bar（）经过定义可以执行

函数在定义阶段只会检测语法，不会执行其中的代码，所以一些简单语法错误我们在定义阶段都可以发现，但是函数逻辑上的错误只有执行之后才可以发现

定义函数的三种形式

第一种（无参）：应用场景就是执行一些简单的操作，比如与用户交互，打印

del  msg（）
     print（‘hello  world’）
#无参

第二种（有参）：需要根据外部传来的参数，才可以执行相应的逻辑

del  tell_msg（tag，n）：
      print（tag*n）
#有参

第三种（空函数）：设计代码结构

def auth(user,password):                             
    '''                                                           
    auth function                                                 
    :param user: 用户名                                              
    :param password: 密码                                           
    :return: 认证结果                                                 
    '''                                                           
    pass                                                          
                                                                  
def get(filename):                                                
    '''                                                           
    :param filename:                                              
    :return:                                                      
    '''                                                           
    pass                                                          
                                                                  
def put(filename):                                                
    '''                                                           
    :param filename:                                              
    :return:                                                      
    '''                                                           
def ls(dirname):                                                  
    '''                                                           
    :param dirname:                                               
    :return:                                                      
    '''                                                           
    pass 

#定义时无参，调用时也不用传入参数

#定义时有参，调用时也应该传入参数

#空函数可以在函数的具体定义没有思路的时候用，防止程序报错，可以提前编写有想法的程序，提高编写效率

3、调用函数

必须遵循先定义，再调用

函数名加括号即调用

def func1():
    print("Hello world")
func1()  # 函数名加括号，调用func1函数

定义阶段：定义阶段，只检测语法，不执行函数体代码
调用阶段：根据函数名找到函数的内存地址，然后执行函数体代码

def func1():
    print("我是func1")
    func2()     

def func2():
    print("我是func2")
    
func1()

调用函数的三种形式

1、直接调用
def func1():
    print("Hello world")
func1()  # 函数名加括号，调用func1函数

2、
def foo(x,y):
    if x > y:
        return x
    else:
        return y

res = foo(5,3)
print(res)

3、
def foo(x,y):
    if x > y:
        return x
    else:
        return y
        
count = foo(5,3)+1
print(count)

4、函数返回值（return）

1.没有return  返回None

2.return 一个值，返回一个值

3.return 用逗号分隔多个值，返回一个元组

4.return返回的值没有类型限制

5.return是函数结束的标志，执行一次就结束

5、函数的参数

5.1、形参与实参

形参：在定义函数时括号内的定义的函数。相当于变量中的‘变量名’

实参：在调用函数时，括号内传入的值。相当于变量当中的“变量的值”

函数在调用的时候将值绑定到变量名上，函数调用结束之后，解除绑定

5.2、参数的具体应用

1、位置参数（按照从左到右的顺序定义的参数）

在定义函数时按照位置定义的函数就叫做位置函数

特性：在调用函数时必须按照位置为形参传值，多一个不行，少一个也不行

# def foo(x,y,z):
#     print(x,y,z)

# foo(1,2,3)

# 再调用函数时，按照位置定义的实参，称为位置实参

# 位置实参会与形参一一对应

2、关键字参数

再调用函数时按照key-value的形式定义的实参，称为关键字参数，关键字函数相当于指名道姓的为形参传值，意味着即使不按照位置传值，也可以为指定的参数传值

# def foo(x,y,z):
#     print(x,y,z)
# foo(x=1,y=3,z=5)

在调用函数时，位置实参可以和关键字参数混合使用，但是要注意以下几点：

1、必须遵循形参的规则

2、不可以为同一个形参重复传值

3、位置实参必须放到关键字实参前面

# def  foo(x,y,z)
#       print(x,y,z)
# foo(1,y=2,z=3)

3、默认参数

在定义阶段已经为某个形参赋值，那么该形参就称为默认参数，定义阶段有值就意味着调用阶段可以不传值。

默认参数的值只在定义阶段赋值一次，也就是说默认参数的值在定义阶段就已经固定死了

# def register(name,age,sex='male'):
#     print(name,age,sex)

# register('sean',20)
# register('able',25)
# register('jacky',30)
# register('lve',26,'female')

#  默认参数的值应当设为不可变类型

# def register(name,hobby,l=None):
#     if l is None:
#         l=[]
#     l.append(hobby)
#     print(name,l)
# register('sean','paly')
# register('able','read')
# register('jacky','cook')
# register('lve','music')

对于经常需要变化的值，需要将对应的形参定义成位置形参

对于大多数情况都一样的情况，就需要将对应的形参定义为默认参数

4、可变长参数

可变长度指的是参数的个数可以不固定，实参当中又按照位置定义的实参和按照关键字定义的实参，所以可变长的实参指的就是按照这两种形式定义的实参个数可以不固定

其中在位置实参当中处理这种问题的方式是：“用*号将溢出的位置实参全部接收，然后保存成元组的形式赋值给args”

#  def   foo(x,y,z,*args)
#           print(x,y,z)
#           print(args)

#  foo(1,2,3,4,5,6,7,8,9)   #1,2,3,(4,5,6,7,8,9)
#  foo(1,2,3,*(4,5,6,7,8,9)) #*后面的实参可以是字符串、元组、列表
#  foo(1,2,3,*[4,5,6,7,8,9])
#  foo(1,2,3,*'hello')

关键字参数：“用**将溢出的关键字实参全部接收，然后保存成字典的形式赋值给kwargs”

# def  foo（x,y,z,**kwargs):
#        print(x,y,z)
#        print(kwargs)

# foo(1,2,3,a=4,b=5,c=6)  # 1,2,3,{'a':4,'b':5,'c':6}