函数概念：
1.为什要有函数
组织结构不清晰，可读性差，代码冗余，可扩展性差。
2.什么是函数
具备某一个功能的工具---》函数
事先准备工具-》函数的定义
拿来就用、重复使用-》函数的调用
ps：先定义后调用
函数的分类：
1.内置函数：len，max(10,11)，help(函数名),python中给你写好的。
2.自定一函数def
语法：
def 函数名(参数1，参数2，...):
"""注释"""
函数体
return 返回值
函数的使用：
内置的函数：（直接使用 就好）
l1=[1,2,3,4,5]
print(max(l1)) 5
自定义函数：
# def func(): #定义i阶段相当于在内存空间中的定义了这个名字，就相当于写了一个变量
# print("hello world") #定义和函数体代码之间需要空4个空格
# return 333
#
#
# func() #调用阶段，执行函数体代码
#hello world #########返回值的使用：
#return的特点：
#1、 函数内可以有多个return，但是只能执行一次return
#2、 执行return函数就立刻结束，并且return的后值当做本次调用的结果返回
# def func():
# print("hello world")
# return 333 #函数的返回值，可以当做变量使用，不限制类型。
#
# a = func()
# print(a) #hello world
#333
函数的参数：
1.无参函数
def func():
print("hello world")
return 333
2.有参函数
# def auth(name,password): #括号中即为参数，函数可以当做变量来使用
# if name =='egon' and password == '123':
# print('login successfull')
# else:
# print('user or password err')
#
# def interactive():
# name=input('name>>: ').strip()
# password=input('password>>: ').strip()
# auth(name,password)
#
# interactive()
3.空函数:
def func():
pass #即为什么也不做的意思，在写代码的时候，用于逻辑的填补。
'''
1 为什么要有函数？没有函数带来的困扰？
组织结构不清晰，可读性差
代码冗余
可扩展性差 2 什么是函数
具备某一个功能的工具---》函数 事先准备工具-》函数的定义
拿来就用、重复使用-》函数的调用
ps：先定义后调用 3 函数的分类：
内置函数：len，max(10,11)，help(函数名)
自定义函数：def
语法：
def 函数名(参数1，参数2，...):
"""注释"""
函数体
return 返回值
''' #'函数即是变量'
# def print_tag():
# print('*'*20)
#
# def print_msg(): #print_msg=<function print_msg at 0x00000000027EA8C8>
# print('hello world')
#
#
# # print(print_msg)
# # print(print_tag)
#
# print_tag()
# print_msg()
# print_tag() #2、定义函数阶段都发生了什么事：只检测语法，不执行代码
#定义阶段
# sex='male'
# def auth():
# sex
#
# name=input('name>>: ').strip()
# password=input('password>>: ').strip()
# if name =='egon' and password == '123':
# print('login successfull')
# else:
# print('user or password err')
#
# #调用阶段
# auth() #3、函数的使用：先定义后调用 # def bar():
# print('from bar')
#
# def foo():
# print('from foo')
# bar()
#
# foo() # #定义阶段
# def foo():
# print('from foo')
# bar()
#
# def bar():
# print('from bar')
#
# #调用
# foo() # # 定义阶段
# def foo():
# print('from foo')
# bar()
#
# # 调用
# foo()
#
# def bar():
# print('from bar')
# #4 定义函数的三种形式
#第一种：无参函数
#第二种：有参函数
#第三种：空函数 # def auth():
# name=input('name>>: ').strip()
# password=input('password>>: ').strip()
# if name =='egon' and password == '123':
# print('login successfull')
# else:
# print('user or password err')
# # def my_max(x,y):
# if x >= y:
# print(x)
# else:
# print(y)
#
# my_max(1,2) # def auth(name,password):
# if name =='egon' and password == '123':
# print('login successfull')
# else:
# print('user or password err')
#
# def interactive():
# name=input('name>>: ').strip()
# password=input('password>>: ').strip()
# auth(name,password)
#
# interactive() def auth():
pass def put():
pass def get():
pass def ls():
pass
tag警报器
exp_str = 'id<5'
key=['>','=','<']
res=[]
char=''
opt=''
tag=False
for i in exp_str:
if i in key:
tag=True
if len(char) !=0:
res.append(char)
char=''
opt+=i
if not tag:
char+=i
if tag and i not in key:
tag=False
res.append(opt)
opt=''
char+=i
else:
res.append(char) print(res)
这个例子将 一个 id<5 之类的字符分开变成 ['id', '<', ''] ,先设置一个空列表，用来控制输出，
将列表改变，变成以某个字符为特殊的分割点的列表，其中非特殊字符两侧的字符串相互拼接。
函数的返回值
#return的特点：
#1、 函数内可以有多个return，但是只能执行一次return
#2、 执行return函数就立刻结束，并且return的后值当做本次调用的结果返回
# def foo(x,y):
# return x+y
#
# res=foo(1,2)
#
# def my_max(x,y):
# if x >= y:
# return x
# else:
# return y
#
# res=my_max(1,2)
# print(res) # def foo():
# print('first')
# return 1
# print('second')
# return 2
# print('third')
# return 3
#
# res=foo()
# print(res) #1、返回的值没有类型限制
# def bar():
# print('from bar')
#
# def foo():
# return bar
# print(foo() is bar) #2:return返回值的个数
#2.1: 没有return:默认返回None
#2.2：return 值：值本身
#3.3： return 多个值:返回一个元组 # def foo():
# pass
# return 1,'a',[1,2]
# print(foo()) #函数调用的三种形式
def my_max(x,y):
if x >= y:
return x
else:
return y # res1=my_max(1,2) # res2=my_max(1,2)*10 # res3=my_max(my_max(1,2),3)
# print(res3) range(len([1,2,3]))
函数的参数：
#函数的参数分类两种：
#形参：在定义阶段括号内指定的参数，相当于变量名
#实参：在调用阶段括号内传入的值称之为实参，相当于值
#在调用阶段，实参的值会绑定给形参，在调用结束后解除绑定
# def foo(x,y): #x=1,y=2
# print(x,y)
#
# foo(1,2) #在python中参数的分类：
#1、位置参数：按照从左到右的顺序依次定义的参数
#位置形参：必须被传值，多一个少一个都不行
#位置实参：与形参一一对应传值
# def foo(x,y):
# print(x,y)
#
# foo(2,1) #2、关键字参数：在函数调用时，按照key=value的形式定义的实参
#特点：指名道姓地给形参传值，不再依赖与位置
def foo(name,age,sex):
print(name,age,sex) # foo('egon',18,'male')
# foo(sex='male',age=18,name='egon',)
#注意：
#1、 关键字实参必须在位置实参的后面
#2、 不能为同一个参数赋值多次 # foo('egon',sex='male',age=18,name='egon') #3、默认参数：在函数定义阶段，就已经为形参赋值了
#特点：定义阶段已经有值意味着调用阶段可以不用传值
#位置参数通常用于经常变化的参数，而默认参数指的是大多数情况下都一样的
# def foo(x,y=1):
# print(x,y) # foo(1,2)
# foo(y=3,x=1)
# foo(111)
# foo(x=1111) # def register(name,age,sex='male'):
# print(name,age,sex)
#
# register('egon1',18)
# register('egon2',18)
# register('egon3',18)
# register('alex',38,'female') #注意：
#1、默认参数必须放到位置形参的后面
# def register(name,sex='male',age,):
# print(name,age,sex)
#2、默认参数的值只在定义时被赋值一次
#3、默认的参数的值通常应该是不可变类型
# res=1
# def foo(x,y=res):
# print(x,y)
#
# res=10
# foo('aaaaaaaa') #4 可变长参数：在调用函数时，实参值的个数不固定
#实参的形式有：位置实参和关键字实参，
#形参的解决方案：*，** #*args的用法
# def foo(x,y,*args): #z=(3,4,5,6)
# print(x,y)
# print(args)
#
# # foo(1,2,3,4,5,6)
#
# foo(1,2,*[3,4,5,6]) #foo(1,2,3,4,5,6)
# foo(*[1,2,3,4,5,6]) #foo(1,2,3,4,5,6) # def foo(x,y):
# print(x,y)
#
# foo(*(1,2)) #foo(1,2) #**kwargs
# def foo(x,y,**kwargs): #kwargs={'c':5,'a':3,'b':4}
# print(x,y)
# print(kwargs)
#
# # foo(y=2,x=1,a=3,b=4,c=5)
#
# foo(y=2,**{'c':5,'x':1,'b':4,'a':3}) #foo(y=2,a=3,c=5,b=4) # def foo(name,age):
# print(name,age) # foo(**{'name':'egon','age':18})
# foo({'name':'egon','age':18}) # def bar(x,y,z):
# print(x,y,z)
#
# def wrapper(*args,**kwargs): #args=(1,),kwargs={'z':2,'y':3}
# # print(args,kwargs)
# bar(*args,**kwargs) #bar(*(1,),**{'z':2,'y':3}) #bar(1,z=2,y=3,)
#
# wrapper(1,z=2,y=3) #命名关键字参数：指的是定义在*后的参数，该参数必须被传值（除非有它有默认值），而且必须按照key=value的形式传值
# def foo(x,y,*args,m=100000,n):
# print(x,y)
# print(args)
# print(m,n)
#
# foo(1,2,3,n=4,)
#