一、函数
1.什么是函数？
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率，可扩展性强。
2.函数的分类
在python中函数分两类：内置函数，自定义函数
1）内置函数
python本身自己定义的函数，可直接调用
sum
max
min
a=len('hello')
print(a)
b=max([1,2,3])
print(b)
2）自定义函数
自己根据需求，按照函数定义方法去自定函数
3.函数的定义
1)为什么要定义函数？
先定义后使用，如果没有定义而直接使用，就相当于引用了一个不存在的变量名
函数的使用包含两个阶段：定义阶段和使用阶段
注：定义函数，只检测语法，不执行代码
2)函数定义的语法
def functionname( parameters ):
"函数_文档字符串"
function_suite
return [expression]
例如：
def printme( str ):
print str
return
3）定义函数的三种形式
#一：无参数函数：如果函数的功能仅仅只是执行一些操作而已，就定义成无参函数，无参函数通常没有返回值
def print_star():
print('#'*6)
#二：定义有参函数:函数的功能的执行依赖于外部传入的参数，有参函数通常都有返回值
# def my_max(x,y):
# res=x if x >y else y
# return res
# 三元表达式
x=10
y=2
# if x > y:
# print(x)
# else:
# print(y)
#
res=x if x > y else y print(res)
#三：空函数
在一开始思考代码架构时，可以先把扩展功能写下来，后期完善
# def auth():
# """认证功能"""
# pass
# auth()
def insert():
"""插入功能"""
pass
def select():
"""查询功能"""
pass
def delete():
"""删除功能"""
pass
def update():
"""更新功能"""
pass
4）函数的调用
def foo():
print('from foo')
def bar(name):
print('bar===>',name)
#按照有参和无参可以将函数调用分两种
foo() #定义时无参，调用时也无需传入参数
bar('egon') #定义时有参，调用时也必须有参数
#按照函数的调用形式和出现的位置，分三种
foo() #调用函数的语句形式
def my_max(x,y):
res=x if x >y else y
return res
# res=my_max(1,2)*10000000 #调用函数的表达式形式
# print(res)
res=my_max(my_max(10,20),30) #把函数调用当中另外一个函数的参数
print(res)
5）函数的参数
函数的参数分两种：形参(变量名)，实参（值）
#定义阶段 def foo(x,y): #x=1,y=2 print(x) print(y)
#调用阶段 foo(1,2)
详细的区分函数的参数分为五种：
位置参数，关键字参数，默认参数，可变长参数（*args，**kwargs）,命名关键字参数
- 位置参数
def foo(x,y,z):#位置形参:必须被传值的参数
print(x,y,z)
foo(1,2,3) #位置实参数：与形参一一对应
输出：
1 2 3
- 关键字参数
def foo(x,y,z):
print(x,y,z)
foo(z=3,x=1,y=2)
#关键字参数需要注意的问题：
# 1：关键字实参必须在位置实参后面
# 2: 不能重复对一个形参数传值
# foo(1,z=3,y=2) #正确
# foo(x=1,2,z=3) #错误
# foo(1,x=1,y=2,z=3)
- 默认参数
# def register(name,age,sex='male'): #形参：默认参数
# print(name,age,sex)
#
# register('asb',age=40)
# register('a1sb',39)
# register('a2sb',30)
# register('a3sb',29)
#
# register('钢蛋',20,'female')
# register('钢蛋',sex='female',age=19)
#默认参数需要注意的问题：
#一：默认参数必须跟在非默认参数后
# def register(sex='male',name,age): #在定义阶段就会报错
# print(name,age,sex)
#（了解）二：默认参数在定义阶段就已经赋值了，而且只在定义阶段赋值一次
# a=100000000
# def foo(x,y=a):
# print(x,y)
# a=0
# foo(1)
#三：默认参数的值通常定义成不可变类型
- 可变长参数
*args *会把溢出的按位置定义的实参都接收，以元组的形式赋值给args
def foo(x,y,*args): #*会把溢出的按位置定义的实参都接收，以元组的形式赋值给args
print(x,y)
print(args)
#
foo(1,2,3,4,5)
例如：
# def add(*args):
# res=0
# for i in args:
# res+=i
# return res
# print(add(1,2,3,4))
# print(add(1,2))
输出：
10
3
**kwargs **会把溢出的按关键字定义的实参都接收，以字典的形式赋值给kwargs
# def foo(x, y, **kwargs): # **会把溢出的按关键字定义的实参都接收，以字典的形式赋值给kwargs
# print(x, y)
# print(kwargs)
# foo(1,2,a=1,name='egon',age=18)
例如：
def foo(name,age,**kwargs):
print(name,age)
if 'sex' in kwargs:
print(kwargs['sex'])
if 'height' in kwargs:
print(kwargs['height'])
foo('egon',18,sex='male',height='185')
foo('egon',18,sex='male')
输出：
egon 18
male
185
egon 18
male
foo(*[1,2,3]) #foo(1,2,3)
foo(**{'x':1,'b':2} #foo(x=1,b=2)
- 命名关键字参数
# def foo(name,age,*,sex='male',height):
# print(name,age)
# print(sex)
# print(height)
# #*后定义的参数为命名关键字参数，这类参数，必须被传值，而且必须以关键字实参的形式去传值
# foo('egon',17,height='185')
例如
def foo(x,y,z):
print('from foo',x,y,z)
def wrapper(*args,**kwargs):
print(args) #args=(1,2,3)
print(kwargs) #kwargs={'a':1,'b':2}
foo(*args,**kwargs) #foo(*(1,2,3),**{'a':1,'b':2}) #foo(1,2,3,b=2,a=1)
# wrapper(1,2,3,a=1,b=2)
wrapper(1,z=2,y=3)
输出
(1,)
{'z': 2, 'y': 3}
from foo 1 3 2
6）函数的返回值
return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。
例如
def foo():
print('from foo')
return None
res=foo()
print(res)
输出
from foo
None
补充：
以三种情况返回值都为None：
没有return
return 什么都不写
return None
return 一个值 函数调用返回的结果就是这个值
def foo():
print('from foo')
x=1
return x
res=foo()
print(res)
输出：
from foo
1
return 值1,值2，值3,... 返回结果:(值1,值2，值3,...)
def foo():
print('from foo')
x=1
return 1,[2,3],(4,5),{}
res=foo()
print(res) #打印结果：(1,[2,3],(4,5),{})
a,b,c,d=foo()
print(d)
输出：
from foo
(1, [2, 3], (4, 5), {})
from foo
{}