day3 python 阿狸的进阶之路

函数概念：

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,)
#