1.先定义、后引用
2.函数参数的使用
1---------形参
(一)-------------位置形参
(二)-------------默认形参
2---------实参
(一)-------------位置实参
(二)-------------关键字实参
3-------------* 与 ** 在实参与形参的应用
>>>>>>>>>>>>函数的介绍<<<<<<<<<<<<<<
致命三连击
'''
1、什么是函数： ps：：函数就是盛放代码的容器
工匠干活需要事先准备（工具包=函数）
具备某一功能的工具 = 函数
事先准备工具的过程 = 函数的定义
遇到场景就拿来用 = 函数的调用
所以函数的使用原则： 先定义 后调用
2、为何要用函数
解决下列问题
1、代码组织结构不清晰，可读性差
2、可扩展性差
3、如何用函数
定义的语法：
def 函数名 通常起动词 登录：login 注册
def（参数1，参数2，参数3.....）:
’‘’函数的文档注释‘’‘
代码1
代码2
代码3
return 返回值
一、定义函数
发生的事情：
1、申请内存空间把函数体代码放进去
2、将函数内存地址绑定给函数名
==强调== ：定义函数 只检测语法，不执行代码
def login(): login = 函数的内存地址
print(111)
print(111)
print(111)
x = 10 的意思是等与 10 的内存地址
print(x) >>>>> 10 不过是 python 帮我们完成了取值的工作
but print(login) >>>>打印的是内存地址
二、调用函数
login() 先通过变量名login找到代码，再加上()运行 两件事情
发生的事情：
1、先通过函数名定位找到函数的内存地址
2、函数的内存地址（）触发代码运行
#==强调：调用函数才会执行代码==
定义、调用的几个小例子
def func():
print(111 #==语法错误
print(111)
x #==语法没问题，但是调用会出错，x未定义
=======================
def bar()
print('from bar')
def foo():
print(from foo)
bar
foo() #== 正常运行 from bar from foo
======================
def foo():
print(from foo)
bar
def bar()
print('from bar')
foo() #== 正常运行 先定义 后调用
三、定义函数的三种形式
3.1 无参 #已经写死了 不需要输入内容
def func():
print('xxx')
def say():
print('>>>>>')
print('happy')
def login():
inp_name = input('username>>>>:') #== 虽然输入内容 不过是 input 提供的==
inp_pwd = input('pwd>>>>>:')
if inp_name == 'liu' and inp_pwd == '123':
print('successful login...')
else:
print('username or pwd error')
login()
3.2 有参
def func():
print(x)
func(111) 可以输入变化的值
def max2(x,y)
if x > y:
print(x)
else:
print(y)
max2(10,20)
3.3空
def login(): #==用来写程序构思搭建
psss 或 ...
四、调用函数的三种形式
4.1 语句
len('hello')
4.2 表达式
res = len('hello') *10
print(res)>>>>>> 50
4.3 可以当作参数传给另一个函数
print（len('hello'))
>>>>>>>>>>函数参数使用<<<<<<<<<<
总体分为两大类
1、形参：在函数定义阶段括号内指定的参数，称之为形式参数，简称形参 等同于变量名
2、实参：在函数调用阶段括号内传入的值，称之为实际参数，简称实参 等同于变量值
形参与实参的关系
在调用函数时，实参值会绑定给形参名，在函数调用完毕解除绑定
def func (x,y):
# x=111
# y=222 #== 相当于把 111赋值给 x 把222赋值给 y
print(x,y)
m=111
n=222
func(111,222)
>>>>>>>>>>形参系列<<<<<<<<<<
一、位置形参：在定义函数时，按照从左到右的顺序依次定义变量名，称之为位置形参
特点：每次调用时，必须被赋值，不可多不可少
def func(x,y):
print(x)
print(y)
func(1,2)
二、默认形参：在定义函数时，就已经为某个形参赋值，称之为默认形参
特点：调用时可以不用赋值 非要赋值 也行。。
def func(name,age=18):
print(name)
print(age)
func('liu') #== 位置形参，‘liu'会赋值给 name 下面会详细说明
注意：：1、可以混用位置形参和默认形参，但是必须是位置形参在前，默认形参在后
2、默认形参的值通常是==不可变类型==
3、默认形参的值，是在==函数定义的阶段赋值==
def func(name,hobby,hobbies = None): #== 先把hobbies定义为空
if hobbies is None: #== 每次循环为空的时候，
hobbies = [ ] #== 先定义为 #== 得到都是空列表
hobbies.append(hobby) #== 然后把个人爱好加上去，
print('%s的爱好是%s'%(name,hobbies) #== 最后得到的不会叠加
func('liu','study') >>>>>>> liu 的爱好是['study']
func('li','read')
func('egon','play')
func('lili','eat',['moive']) lili的爱好是['eat','moive']
>>>>>>>>>>实参系列<<<<<<<<<<
二、位置实参：在调用函数的时候，从左到右依次传入的值，称之为位置实参
特点：按照位置为形参赋值，一一对应 和列表 list 类似
func('liu',18)
func(18,'liu')
三、关键字实参：在调用函数的时候，按照 key=value 的形式传值，称之为关键字传值
特点：可以打乱顺序 仍然可以为指定参数赋值，和字典dict类似 字典也无序
func(x=1,y=2)
#==注意：可以混用位置实参与关键字实参，但是...
1、位置实参必须在关键字实参的前面
2、不能为同一形参重复赋值
例：func('liu',age=18)
func(age=18.'liu') #== Error，关键字实参必须在位置实参后
错误小例子
def foo(x,y,z):
pass
foo(1,y=2.3) #== Error，位置实参必须在前
foo(1,y=2,z=3,x=4) ##Error x 重复赋值
>>>>>>>>>>可变长系列<<<<<<<<<<
可边长参数指的是在调用函数时，传入的实参个数不固定，对应着必须有特殊形式的形参来接收溢出的实参
实参无非两种形式
溢出位置实参用 * 接收
溢出的关键字实参用 ** 接收
* 和 ** 在形参中是一种汇总的行为
1、* 在形参中的应用： * 会将溢出的位置和合并成一个元组，然后赋值给紧跟其后的形参名
def func(x,*args):
print(x) >>>>> 1
print(args) >>>>>>(2,3,4)
func(1,2,3,4)
2、** 在形参中的应用： **会将溢出的关键字实参合并成一个字典，然后赋值给紧跟其后的形参名
def func(x,**kwargs):
print(x) >>>>> 1
print(kwargs) >>>>> {'a':1,'b':2}
func(1,a=1,b=2)
小应用
def my_sun(*args):
res = 0
for i in args:
res += i
print(res) >>>>>> 10
my_sum(1,2,3,4)
* 和 ** 在实参中是一种打散行为
* 在实参中的应用： * 后跟可以被for循环遍历的任意类型 * 会将紧跟其后的那个值打散成位置实参
def func(x,y,z):
print(x)
print(y)
print(z)
func(*[11,22,33]) >>>11 22 33
func('hello') '>>>>>>h','e','l','l','o'
func(*{'k1':111,'k2':222}) >>>>'k1','k2'
**在实参中的应用： ** 只能跟字典类型，会将字典打散成关键字实参
例:
def index(x,y,z)
print(x,y,z)
def wrapper(*args,**kwargs):
print(args)
print(kwargs)
index(*args,**kwargs) >>>>>>index(1,2,3,a=1,a=2）
wrapper(1,2,3,a=1,a=2)
了解：命名关键字形参： 在* 与**中间的形参称为命名关键字形参
特点：必须按照key=value的形式传值
def func(x,*args,y=222,z,**kwargs):
print(x)
print(args)
print(y)
print(z)
print(kwargs)
func(x,args,y,z,kwargs)
>>>>>>>>>>return<<<<<<<<<<
def max2(x,y):
if x > y:
return x
else:
return y
res = max2(10,20)
print(res * 12)
return详解：
1、函数可以有多个return，但只要执行一次return，整个函数就立即结束，并且将return后的值当做本次调用的结果返回
def func():
print("=====")
return 111
print("****")
return 222
print("----------")
return 333
res = func()
print(res)>>>>>>>>>> ========
2、return后的返回值有三种情况
（1）return 值：返回的就是这一个值
（2）return 值1,值2,值3：返回的一个元组
def func():
return 111,"xxx",[22,33]
res = func()
print(res)>>>>>>> (111,'xxx',[22,33])
（3）函数内可以没有return、或者return None、或者return：返回的都是None
def func():
print(111)>>>>>>正常输出 111
return >>>>>遇到return 程序终止，返回None
print(2222)
res = func()
print(res)>>>>111 None
乘风破浪会有时，直挂云帆济沧海...