Python函数

一、函数简介

python中可以将某些具备一定功能的代码写成一个函数，函数可以在一定程度上减少代码的冗余，节约书写代码的时间。

Python中定义好的函数是可以通过函数名称调取并重复使用的模块。

Python有内置函数，如print()函数；也支持创建自定义函数。

二、函数定义

函数的使用必须遵循’先定义，后调用’的原则。函数的定义就相当于事先将函数体代码保存起来，然后将内存地址赋值给函数名，函数名就是对这段代码的引用，这和变量的定义是相似的。没有事先定义函数而直接调用，就相当于在引用一个不存在的’变量名’。

定义函数的语法

def 函数名(参数1,参数2,...):
	"""文档描述"""
	函数体
	return 值

1. def 就是定义函数的关键字，它不能够省略，必须写
2. my_len()：函数名，函数名的命名遵循变量的命名规范，他也是必填的，不能省略的，括号不能省略
3. a, b称为是函数的参数，是可选的，可有可无
   参数就是执行函数的一些前提条件
4. ‘’‘函数注释’‘’
   注释不参与函数的执行，只起到函数功能的提示作用，以及各个参数是什么意思
   # 可有可无的，但是，推荐每个函数都加上函数注释
5. #函数体
   才是函数的核心，它是函数所具备的核心功能，应该是必须有的，pass
   没有函数体的函数是没有意义的函数，一般情况都是要有函数体的
6. 返回值 return 函数的返回值
   # 返回值也是可选的，可以有返回值，也可以没有返回值，但是一般情况下都要有返回值
   # 一个函数只能有一个返回值…

参数是函数的调用者向函数体传值的媒介，若函数体代码逻辑依赖外部传来的参数时则需要定义为参函数，

def my_min(x,y):
    res=x if x < y else y
    return res

否则定义为无参函数

def interactive():
    user=input('user>>: ').strip()
    pwd=input('password>>: ').strip()
    return (user,pwd)

函数体为pass代表什么都不做，称之为空函数。定义空函数通常是有用的，因为在程序设计的开始，往往是先想好程序都需要完成什么功能，然后把所有功能都列举出来用pass充当函数体“占位符”，这将使得程序的体系结构立见，清晰且可读性强。例如要编写一个ftp程序，我们可能想到的功能有用户认证，下载，上传，浏览，切换目录等功能，可以先做出如下定义：

def auth_user():
    """user authentication function"""
    pass

def download_file():
    """download file function"""
    pass

def upload_file():
    """upload file function"""
    pass

def ls():
    """list contents function"""
    pass

def cd():
    """change directory"""
    pass

之后我们便可以统筹安排编程任务，有选择性的去实现上述功能来替换掉pass，从而提高开发效率。

三、函数的分类

1. 内置函数

Python解释器中原本就存在的，不需要定义，可以直接使用
len print input 之前学习的数据类型的各个使用方法

2. 自定义函数

程序员自己写的函数，必须先定义后调用
1.无参数：函数在定义阶段就没有参数

def my_len():
	pass
	
my_len()

2.有参数：在函数定义阶段有参数存在

def my_len(a, b):
	pass

my_len(1, 2)

3.空函数：

def my_len():
            pass
        
       """作用就在于可以帮助我们梳理业务逻辑""" 
 	def register():
        pass
    
    def login():
        pass
    
    def address():
        pass
    
    def order():
        pass

3.函数的返回值

关键字 ：return

关键字：return
def home():
    print(123)
    # return # 代码走到这立刻结束
    # print('hello')
    return 1, 2, 3 # (1, 2, 3)



res = home() # 把home函数执行之后返回的结构赋值给res变量
print(res) # None (1, 2, 3)
print(res[0]) # None (1, 2, 3)
print(res[1]) # None (1, 2, 3)
print(res[2]) # None (1, 2, 3)
"""
1. 每一个函数不行必须要有返回值的，可有可无
2. 当函数中没有return关键字，那么，函数的返回结果是什么?
3. 只有是return关键字后面的数据才是函数的返回结果
4. 一个函数中只能有一个return关键字，函数体体代码只有遇到return直接退出
5. return后面可以返回值多个值，逗号隔开，以元组的形式返回
"""		

四、函数参数

1.形式参数

函数在定义阶段中括号中定义的变量名的就是形式参数，简称形参

def index(a, b):# a,b 就是形式参数
	pass

2.实际参数

函数在调用阶段中，括号中写的变量值就是实际参数，简称实参

def index(a, b):
	pass
index(1, 2)#1,2 就是实际参数

形参和实参的关系：

简单来说就是把形参当做是变量名，实参就是变量值
形参和实参在函数调用阶段时临时绑定，函数调用结束时，两者断开

函数传参形参其实就只有一种情况：变量名
但是实参有多形式：变量值、变量名、函数返回值、等，本质还是变量值

3.位置参数

位置参数
函数在括号中从左往右依次写入的参数就是位置参数

   def index(a, b, c):
        pass

位置形参
在函数定义阶段括号中从左往右依次写入的变量名就是位置形参

def index(a, b, c):
    pass
# a,b,c就是位置形参

位置实参
在函数调用阶段括号中从左往右依次传入的变量值就是位置实参

index(1, 2, 3)
# 1, 2, 3称为是位置实参
    
"""位置参数的特点：形参和实参是一一对应的"""

1.定义一个比较大小的函数

def my_max(a, b):
	if a > b:
		return a
	return b

2.调用函数
位置参数的传递，实参少一个不行，过一个也不行，参数必须一一对应

res = my_max(10, 2, 3, 4) # 2 10
res = my_max(10, 2,) # 2 10
print(res)
my_max(y=10, x=20, b=1, a=2) # 指名道姓的传递
res = my_max(b=1, 2) # 不可以，位置参数不能够放在关键字的后面
res = my_max(2,b=1) # 可以，位置参数不能够放在关键字的后面
res = my_max(a=1,2) # 可以，位置参数不能够放在关键字的后面
res = my_max(2,a=1) # 不可以，位置参数不能够放在关键字的后面
'''位置参数不能够放在关键字参数的前面！！！ 越短的越靠前'''

# 关键字实参：可以打破按照顺序传递参数的规则
	特点：严格按照变量名=变量值的形式一一传递

debug模式

1. 先打断点，在代码的左侧点一下鼠标的左键，会出现一个红点
2. 右键选择debug选项

4.默认参数

定义：
在函数定义阶段已经给形参赋予了变量值
1. 如果你在函数定义的时候，给形参赋予值之后，调用函数的时候，实参如果你没有给，就使用默认的
2. 如果你在函数调用的时候，给了值，就使用你给的值，不在使用默认的

def index(name, age, gender='male'):
	print('name:%s, age=%s, gender=%s' % (name, age, gender))
index('qren',18) # name:qren, age=18, gender=male
index('siqren',19,'female') # name:siqren, age=19, gender=famale

5.可变长参数

参数的长度可变指的是在调用函数时，实参的个数可以不固定，而在调用函数时，实参的定义无非是按位置或者按关键字两种形式，这就要求形参提供两种解决方案来分别处理两种形式的可变长度的参数

1.无论我传入多少个位置参数，函数都能够正常的被调用

号在形参中的使用：它会接受多余的位置参数，然后组成元组的形式赋值给号后面的变量名

def index(a, b, c, *args):
	print(a, b, c, args) #123(4,5,6,7,8,9)
	
	
index(1, 2, 3, 4, 5, 6, 7, 8, 9)

2.无论我传入多少个关键字参数，函数都能够正常的被调用

*号在形参中的使用：会接受多余的关键字参数，并且组装成字典的形式赋值给**号后面的变量名

def index(x, y, q, z, **a):
    # print(a) # {'x': 1, 'y': 2, 'm': 3, 'n': 4, 'z': 5, 'p': 6, 'q': 7}
    print(x, y, a)  # {'m': 3, 'n': 4, 'z': 5, 'p': 6, 'q': 7}
    print(x, y, q, a)  # {'m': 3, 'n': 4, 'z': 5, 'p': 6}


index(x=1, y=2, m=3, n=4, z=5, p=6, q=7)
'''补充：
    *和和**号后面的变量名可以随便叫
    但是：在Python中，推荐使用*args **kwargs
    args：arguments  位置参数
    kwargs: keywords arguments 关键字参数
    
'''

3.无论我传入多少个位置参数和关键字参数，函数都能够正常的被调用

def index(a, b, c=1, *args, **kwargs, ):
    print(args)  # (1, 2, 3, 4)
    print(kwargs)  # {'x': 10, 'y': 20, 'z': 30}


index(1, 2, 3, 4, x=10, y=20, z=30)



def index(**kwargs):
    print(kwargs)


d = {'username': 'kevin', 'age': 19, 'gender': 'male', 'salary': 2000, 'sex': '1', 'sex1': 2}

index(**d)

6.命名关键字参数

#命名关键字传参：在形参中会出现*的用法，如果出现在*号后面的形参，那么，实参传递的时候，必须以关键字的形式传递

def register(name,age,*,sex,height,salary): #sex,height为命名关键字参数
   pass

# register('kevin', 10, 'male', 1.9)
register('kevin', 10, sex='male', height=1.9, salary=2000)