函数 function：
什么是函数：函数是可以重复执行的语句块，可以重复调用
作用：
1、用于封装可重复执行的语句，提高语句的可重用性
2、定义用户级别的函数
函数定义语句 def语句的语法：
def 函数名(参数列表)：
函数的语法说明：
1、函数的名字就是语句块的名称2、函数名的命名规则与变量名命名规则相同(必须为标识符)
3、函数名是一个变量(不要轻易对其赋值)
4、函数的自己的名字空间，在函数内部可以访问外部的变量，但外部的语句不能访问函数内部的变量
5、函数如果不需要传入参数，则参数列表可以为空
6、语句部分不能为空，如果为空需要填充pass语句
示例1：
def say_hello():
print('hello world')
print('hello tarena')
print('hello everyone')
函数调用：
函数名(实际调用传递参数)注：
实际调用传递参数简称'实参'
调用说明：
1、函数调用是一个表达式2、如果没有return语句，函数执行完以后返回None对象
3、如果函数需要返回其他的对象，需要用到return语句
示例2：
# 带有参数的函数的定义
# ! /usr/bin/python3
# 此示例示意定义一个带有参数的函数
def mymax(a, b):
if a > b:
print('最大数是:', a)
else:
print('最大数是:', b)
# 调用带有参数的函数，第一个实参100给形参a，第二个……
mymax(100, 200)
mymax(10000, 5000)
函数定义格式如下：
def print_even(n):pass
函数内部有独立的运行空间，函数外部不能访问函数内的变量
示例：# ! /usr/bin/python3
def test():
x = 100 # 此变量是局部变量，只能在函数内部使用
print(y) # 这是合法的此函数可以访问函数以外的全局变量
y = 200
test() # 调用test
# print(x) # 此时没有x这个变量
return语句：
语法：return[表达式]
注：[]代表其中的内容可以省略
作用：
用于函数中，结束当前函数的执行，返回到调用函数的地方，同时返回一个对象的引用关系
说明：
1、return语句后跟的表达式可以省咯，省咯后相当于return None
2、如果函数内没有return语句，则函数执行
完最后一条语句后返回None(相当于在最后加了一条return None语句)
3、函数调用能够返回一个对象的引用
示例：
# ! /usr/bin/python3
# 此示例示意return语句的用法
def hello():
print('hello world')
print('hello tarena')
return # 用于返回到调用的地方
print('hello everyone')
v = hello()
print(v)
练习：
'''
1、写一个函数mymax，返回两个数的最大值：
'''
def mymax(x, y):
if x >= y:
return x
return y
print(mymax(100, 200))
print(mymax(200, 100))
print(mymax('acd', 'abcd'))
'''
2、写一个函数input_number()
此函数用于读取用户输入的多个整数（用户输入负数时结束输入）
将用户输入的数形成列表返还给调用者
'''
# 方法一
# ! /usr/bin/python3
def input_number():
number = []
while True:
n = int(input('请输入正整数：'))
if n < 0:
break
number.append(n)
return number
if __name__ == '__main__':
n = input_number()
print(n)
print('您输入的最大数是', max(n))
print('您输入数的和是', sum(n))
# 方法二
# ! /usr/bin/python3
def input_number2():
number = []
while True:
n = int(input('请输入正整数：'))
if n < 0:
return number
number.append(n)
if __name__ == '__main__':
n = input_number2()
print(n)
print('您输入的最大数是', max(n))
print('您输入数的和是', sum(n))
python函数的参数传递
传递方式：
位置传参序列传参
关键字传参
字典关键字传参
位置传参：
实际调用参数(实参)的对应关系与形式参数(形参)的对应关系是按位置来一次对应的示意：
def fx(a, b, c):
pass
# ^ ^ ^
fx(1, 2, 3)
序列传参：
序列传参是在函数地调用过程中，用*将序列拆解后按位置进行传递的参数方式
实参和形参通过序列传递和匹配
示例：
def fx(a, b, c):
pass
s1 = [11, 22, 33]#列表
fx(*s1)# 将s1序列拆解后按位置传入fx中
# ! /usr/bin/python3
# 此示例示意序列传参
def fx(a, b, c):
print('a=', a)
print('b=', b)
print('c=', c)
s1 = [11, 22, 33]
# 索引传参
# fx(s1[0],s1[1],s1[2])
# 序列传参
fx(*s1) # * 代表要讲s1 拆解后在依次传入
fx(*'ABC')
fx(*(101, 202, 303))
# fx(*'ABCD') # 有错，序列中有四个参数，但形参是三个
print(*'abc') # 等同于print('a','b','c')
关键字传参：
是指传参时，按着形参的名称给形参赋值实参和形参按名称进行pip
示例：
def fx(a, b, c):
pass
fx(b=22, c=33, a=11) # 11-->a, 22-->b, 33-->c
注：
实参和形参按形参名进行匹配，可以不按位置进行匹配
#! /usr/bin/python3
def fx(a, b, c):
print('a=', a)
print('b=', b)
print('c=', c)
fx(b=22, c=33, a=11)
# fx(b=22, c=33, b=55) # 错的
字典关键字传参
实参为字典，用**拆解字典后在进行关键字传参示例：
def fx(a, b, c):
pass
d = {'c':33, 'b':22, 'a':11}
fx(**d) # 拆解字典在依次按关键字传参
说明：
字典的键名和形参名必须一致
字典的键名必须为字符串
字典的见面要在形参中存在
#! /usr/bin/python3
def fx(a, b, c):
print('a=', a)
print('b=', b)
print('c=', c)
d = {'c': 33, 'b': 22, 'a': 11}
fx(**d) # 拆解字典在依次按关键字传参
# fxc=33, b=22, a=11)
综合传参：
函数的传参方式在能确定形参能唯一匹配到兴宁实参的情况下可以任意组合注：
通常位置传参和序列先传递，其次是关键字传参和字典关键字传参
示例：
def fx(a, b, c, d, e, f):
pass
fx(10, *[20, 30], e=50, **{'d': 40, 'f': 60})
# 以下是错误做法
fx(e=50, **{'d': 40, 'f': 60}, 10, *[20, 30])
*************************以下将函数的形参**********************
函数的缺省参数：
语法：def 函数名(形参名1=默认实参， 形参名2=默认实参2，……)：
语句
示例：
#! /usr/bin/python3
def info(name, age=1, address='不详'):
print('我叫', name, '我今年：', age, '岁，家庭住址：', address)
info('张飞', 30, '中原')
info('Tarena', 10)
info('赵云')
# 运行结果
我叫
张飞
我今年： 30
岁，家庭住址： 中原
我叫
Tarena
我今年： 10
岁，家庭住址： 不详
我叫
赵云
我今年： 1
岁，家庭住址： 不详
说明：
缺省参数必须自右至左依次存在
缺省参数可以有0个1个或多个，甚至全部都有缺省参数
缺省参数的绑定对象存在于函数内，同函数的生命周期一致
重要**示例：
def fn(a, lst=[]): # ***重要****
^
|
# 不会删除，不会定义新列表
lst.append(a)
print(lst)
L = [1, 2, 3, 4]
fn(5, L) # [1, 2, 3, 4, 5]
fn(6, L) # [1, 2, 3, 4, 5, 6]
fn(1.1) # [1.1]
fn(2.2) # [1.1, 2.2]
函数的形参定义方式：
1、位置形参2、星号元组形参
3、命名关键字形参
4、双星号字典形参
位置形参：
def 函数名(形参名1，形参名2，……)：语句块
星号元组形参：
语法：def 函数名(*元组形参名)：
语句块
作用：
收集多余的位置参数
示例：
#! /usr/bin/python3
# 此示例示意星号元组形参
def func(*args):
print('实参个数是：', len(args))
print('args的值是：', args)
func(1, 2, 3)
func('ABCD', 3.14, 100, True, None)
命名关键字形参：
语法：def 函数名(*, 命名关键字形参):
语句块
或
def 函数名(*args,命名关键字形参):
语句块
作用：
所有的命名关键字形参都强制调用者采用关键字传参或字典关键字传参的方式传递
示例：
#! /usr/bin/python3
def myfun(a, *, k):
print('a=', a)
print('k=', k)
# myfun(100, 200) # 错的
myfun(100, k=200) # k强制使用命名关键字传参
myfun(100, **{'k': 200}) # 字典关键字传参
双星号字典形参：
语法：def 函数名(**字典形参名)
语句块
作用：
收集多余的关键字传参
注：
字典形参名通常叫"kwargs"
示例：
#! /usr/bin/python3
# 此示例示意双星号字典形参的用法
def func(**kwargs):
print('关键字参数的个数是:', len(kwargs))
print('kwargs =', kwargs)
func(name='tarena', age=15)
# 运行结果：
# 关键字参数的个数是: 2
# kwargs = {'name': 'tarena', 'age': 15}
func(a=1, b='BBBB', c=[2, 3, 4], d=True)
# 运行结果：
# 关键字参数的个数是: 4
# kwargs = {'a': 1, 'b': 'BBBB', 'c': [2, 3, 4], 'd': True}
函数参数说明：
位置形参，缺省参数，星号元组形参数，命名关键字形参，双星号字典形参可以混合使用函数参数自左向右的顺序为：
1、位置形参
2、星号元组形参
3、命名关键字形参
4、双星号字典形参
示例：def fn(a, b, *args, c, **kwargs):
pass
fn(100, 200, 300, 400, *'AB', **{'d':'D'}, c=100)
#! /usr/bin/python3
def fn(a, b, *args, c, **kwargs):
print('a=', a)
print('b=', b)
print('args=', args)
print('c=', c)
print('kwargs=', kwargs)
fn(100, 200, 300, 400, *'AB', **{'d': 'D'}, c=100)
'''
上面的结果
a= 100
b= 200
args= (300, 400, 'A', 'B')
c= 100
kwargs= {'d': 'D'}
'''
可以接受任意位置传参和关键字传参的函数：
def fn(*args, **kwargs):pass
#! /usr/bin/python3
def fn(*args, **kwargs):
print('args=', args)
print('kwargs=', kwargs)
fn()
'''
args= ()
kwargs= {}
'''
fn(a=100)
'''
args= ()
kwargs= {'a': 100}
'''
fn('a', a=100)
'''
args= ('a',)
kwargs= {'a': 100}