Python函数初级

Posted 2020-09-22

 

函数

1.

必须遵循的原则：  先定义，再使用  ，函数的定义，与变量的定义相似，

在定义函数阶段，只检测语法，不执行代码，

如果语法错误，也不能执行，如果逻辑有错误，也不能执行

只要定义了，不管在哪都可以执行，

只有在函数名加括号的时候在执行

结果

-----------------------------------------------------------------------------------------

2.

函数返回值

 函数体最终要有一个结果，返回回来，要加return，

有参数函数，要有返回值，

 

返回值：可以返回任意类型
没有return：None
return value: value
return val1,val2,val3 :(val1,val2,val3)--返回多个值，是元组形式


return的效果：只能返回一次值，终止函数的执行

def foo():
    return 1      -----只返回到return1 ，返回值为  1  ，只能执行一个return，返回一个值，
    print(‘=====>‘)
    return 2
    return 3
    return 4

print(foo())
-----------------------------------------------------------------------------------------


3.位置参数与关键字参数

形参与实参：
def foo(x,y): -----形参   就是变量名，
    return x+y

foo(1,2)      -----实参， 就是值，   

x=1,y=2    在函数调用阶段，还是有效

4.

#===================================part1
#位置参数：按照从左到右的顺序依次定义的参数


def foo(x,y):   ----#按位置定义的形参,必须被传值，多一个不行，少一个也不行
    print(x)
    print(y)

# foo(2,10)
#按位置定义的实参,与形参一一对应   x=2,y=10

---

5.

#关键字参数：实参在定义时，按照key=value形式定义
# def foo(x,y):   ---按位置定义的形参，必须一一对应， 不能多，也不能少，
#     print(x)
#     print(y)
#
# # foo(y=10,x=1)    
# foo(y=10,x=1) #关键字参数可以不用像位置实参一样与形参一一对应，指名道姓地传值

6.
把形参固定，研究实参的变化

# foo(1,10)
# foo(x=1,y=10)
# foo(1,y=10)
# foo(y=10,1)  #报错，位置实参在前面
# foo(x=10,1)  #报错，

# foo(1,x=10,y=20)  #实参x重复赋值，


# def foo(x,y,z):
#     print(x)
#     print(y)
#     print(z)
# # foo(1,z=20,10)  #关键字在前，报错
# foo(1,y=2,z=10)

#注意的问题一：位置实参必须在关键字实参的前面
#注意的问题二：实参的形式既可以用位置实参又可以是关键字实参，但是一个形参不能重复传值

7.默认参数  --形参
在定义函数阶段，就给形参传值，

#默认参数：在定义函数阶段，就已经为形参赋值,定义阶段有值，调用阶段可以不用传值
# def func(x,y=10):
#     print(x)
#     print(y)

#形参的应用：值经常变化的需要定义成位置形参，
# 值大多数情况下都一样，需要定义成默认参数
def register(name,age,sex=‘male‘):  #定义注册函数  ，性别可以是默认参数
    print(name,age,sex)

register(‘alex‘,1000)
register(‘wupeiqi‘,9000)
register(‘yuanhao‘,10000)
register(‘王铁蛋‘,10000,‘female‘)
结果

alex 1000 male
wupeiqi 9000 male
yuanhao 10000 male
王铁蛋 10000 female

#默认参数需要注意的问题一：必须放在位置形参后面
#默认参数需要注意的问题二：默认参数通常要定义成不可变类型
#默认参数需要注意的问题三：默认参数只在定义阶段被赋值一次
# x=10
# def func(name,age=x):
#     print(name)
#     print(age)
# x=20         #已经赋值， 在这里再定义没有意义
#
# func(‘egon‘)


# def func(name,age=10,sex=‘male‘,hobby=[‘play1‘,‘play2‘]):
#     print(name)
#     print(age)
#     print(hobby)
#
# func(‘egon‘)
-----------------------------------------------------------------------------------------

8.可变长参数

#可变长参数：可变长指的是实参的个数不固定
#按位置定义的可变长度的实参：*   ----把按位置定义的多出来的参数保存下来

#按关键字定义的可变长度的实参：**   --- 以字典的形式保存下来
#



# def func(x,y,*args): #x=1,y=2,args=(3,4,5,6)  *+变量名  保存多出来的位置实参
#     print(x,y)
#     print(args)         ----以元组的形式保存实参  
#
# func(1,2,3,4,5,6)

# def func(x,y,*args):  #args=(3,4,5,6)
#     print(x,y)
#     print(args)
#
# func(1,2,*(3,4,5,6)) #foo(1,2,3,4,5,6)   --*把后面的数字全部拆开，拆成位置参数，


# def func(x,y,z):
#     print(x,y,z)
#
# # func(1,*(2,3)) #func(1,2,3)  ---拆开成位置参数
# func(*(2,3)) #func(2,3)



#
# def func(x,y=2,z=1):
#     print(x,y,z)
#
#
# func(*(‘a‘,‘b‘,‘c‘)) #func(‘a‘,‘b‘,‘c‘)

kwargs

# def func(x,y,**kwargs): #x=1,y=2,kwargs={‘a‘:1,‘b‘:3,‘z‘:3}
#     print(x,y)
#     print(kwargs)
#
# func(1,y=2,z=3,a=1,b=3)





# def func(x,y,**kwargs): #x=1,y=2,**kwargs=**{‘a‘:1,‘b‘:3,‘z‘:3}
#     print(x,y)
#     print(kwargs)
#
# func(1,y=2,**{‘a‘:1,‘b‘:3,‘z‘:3}) #func(1,y=2,z=3,b=3,a=1)


# def func(x,y=1,z=1):
#     print(x,y,z)
#
# func(**{‘y‘:2,‘x‘:1,‘z‘:3}) #  加  **  代表拆开关键字，与装饰器有关




# def wrapper(*args,**kwargs): #可以接受任意形式，任意长度的参数
#     print(args)
#     print(kwargs)
#
#
# wrapper(1,2,3,3,3,3,3,x=1,y=2,z=3)




#
# def index(name,group):
#     print(‘welcome %s to index page，group is: %s‘ %(name,group))
#
# def wrapper(*args,**kwargs): #可以接受任意形式，任意长度的参数
#     # print(args) #args=(1,2,3)
#     # print(kwargs) #kwargs={‘x‘:1,‘y‘:2,‘z‘:3}
#     index(*args,**kwargs) #index(*(1,2,3),**{‘x‘:1,‘y‘:2,‘z‘:3}) #index(1,2,3,z=3,y=2,x=1)
#
# wrapper(name=‘egon‘,group=‘group1‘)
结果

8.命名关键字

命名关键字参数:定义在*后的形参，这类形参，必须被传值，
而且要求实参必须是以关键字的形式来传值

# def register(**kwargs):
#     print(kwargs)
#     if ‘name‘ in kwargs:
#         print(kwargs[‘name‘])
#     if ‘age‘ in kwargs:
#         print(kwargs[‘age‘])
#
#
# # register(name=‘egon‘,age=18)
# register()



# def register(*args,name=‘egon‘,age):  默认参数一定在位置参数后面，所以name=‘egon ,
                                         就不是默认参数，两个都不是位置参数，也不是默认参数，
                                         是命名关键字参数
#     print(args)
#     print(name)
#     print(age)
#
# # register(name=‘egon‘,age=18)
# register(1,2,2,3,age=10)



#
# def register(name,age,*,group,**kwargs):
#     print(name)
#     print(age)
#     print(kwargs)
#
#
# # register(‘egon‘,18)
# register(‘egon1‘,18,hobby=‘paly1‘,group=‘group1‘)


# def func(x,y=1,*args,z,**kwargs):
#     print(x)
#     print(y)
#     print(args)
#     print(z)
#     print(kwargs)
#
# func(1,2,3,4,5,z=10,a=1,b=2)



#
# def func(x,*args,z=1,**kwargs):
#     print(x)
#     print(args)
#     print(z)
#     print(kwargs)
#
# func(1,2,3,4,5,a=1,b=2,c=3)




参数顺序

#形参：位置形参，默认参数，*args，命名关键字参数，**kwargs可变长关键字参数（）

 

关于函数的形参与实参的对应

1 .  *args   ,  代表取前面的参数把对应的取完，*args取走后面所有的，*是为后面的都是位置参数，

def func(x,y,*args):
    print(x,y,args)
func(1,2,3,4,5)--------------1 2 (3, 4, 5)   ，args得到是元组形式的参数

2.
def register(*args,name,age) :
    print(name)
    print(age)
register(age=19,name=‘egon‘)

结果
egon
19
----------------------------------------------------------------------------------------------
2.   **kwargs

def func(x,y,**kwargs):
    print(x,y,kwargs)
func(1,2,z=3,a=4,b=5)   ------1 2 {‘z‘: 3, ‘a‘: 4, ‘b‘: 5}   得到元组的形式的参数
-----------------------------------------------------------------------------------------------
4.命名关键字参数

def func(**kwargs) :
    print(kwargs)
    if ‘name‘ in kwargs :
        print(kwargs[‘name‘])
    if ‘age‘ in kwargs :
        print(kwargs[‘age‘])
func(name=‘egon‘,age=18)

结果
{‘name‘: ‘egon‘, ‘age‘: 18}            ------得到字典形式，
egon
18
------------------------------------------------------------------------------------------------------

二、名称空间  与作用域

#名字空间：存放名字与值的绑定关系


#名称空间分为三种


#内置名称空间：python解释器自带的名字，python解释器启动就会生成



#全局名称空间：文件级别定义的名字都会存放与全局名称空间，执行python文件时会产生

# x=1
# def func():
#     pass
#
# class Foo:
#     pass
#
# import os
#
# if 1 > 2 :
#     y=3

#局部名称空间:定义在函数内部的名字，局部名称空间只有在调用函数时才会生效，函数调用结束则失效
# def func(x,y): #x=1,y=2
#     z=3

# func(1,2)


#三者的加载顺序：内置名称空间->全局名称空间->局部名称空间

#取值：局部名称空间->全局名称空间->内置名称空间


# # max=10
# def func(): #x=1
#     # max=20
#     print(max)
#
#
# func()



# max=10
#
# def func(): #x=1
#     max=20
#     # print(max)
# func()
#
#
# print(max)
#


# # x=0
# def f1():
#     # x=1
#     def f2():
#         # x=2
#         def f3():
#             # x=3
#             print(x)
#         f3()
#     f2()
#
# f1()

#作用域：作用范围
#全局作用域：内置名称空间与全局名称空间的名字属于全局范围，
            # 在整个文件的任意位置都能被引用，全局有效
#局部作用域：局部名称空间的名字属于局部范围，
            #只在函数内部可以被引用，局部有效



# x=1
# def foo():
#     def f2():
#         print(x)
#     f2()
# def bar():
#     print(x)
#
# foo()
# bar()


# def f1():
#     x=1
#     def f2(): #f2=value
#         # x=2
#         print(x)
#     f2()
# f1()


x=1
def func():
    x=2
    def f1():pass
    # print(dir(globals()[‘__builtins__‘])) #全局作用域name
    # print(locals()) #局部作用域name

func()

print(globals() is locals())


#局部作用域----->全局作用域
-------------------------------------------------------------------------------

三 、函数对象

#函数是第一类对象： 指的是函数可以被当做数据传递

def func():
    print(‘from func‘)

可被引用
f=func

可以当做函数的参数
def func():
    print(‘from func‘)
def foo(x):
    print(x)
    x()

foo(func)

可以当做函数的返回值
def foo():
    print(‘from foo‘)
def bar():
    return foo
f=bar()
print(f)
print(foo)

x=0
def f1():
    x=1
    def f2():
        # x=2
        print(x)
    return f2
f=f1()
# print(f)
f()



可以当做容器类型的元素
def select():
    print(‘select function‘)

func_dic={
    ‘select‘:select,
}

# print(func_dic[‘select‘])
func_dic[‘select‘]()







def select():
    print(‘select func‘)

def delete():
    print(‘delete func‘)

def change():
    print(‘change func‘)

def add():
    print(‘add func‘)


while 1:
    cmd=input(‘>>: ‘).strip()
    if not cmd:continue
    if cmd == ‘select‘:
        select()
    elif cmd == ‘delete‘:
        delete()
    elif cmd == ‘change‘:
        change()
    elif cmd == ‘add‘:
        add()
    else:
        print(‘无效的命令‘)







def select(cmd_l):
    filename=cmd_l[-1]
    pattern=cmd_l[1]

    with open(filename,‘r‘,encoding=‘utf-8‘) as f:
        for line in f:
            if pattern in line:
                print(line)


def delete():
    print(‘delete func‘)

def change():
    print(‘change func‘)

def add():
    print(‘add func‘)

def check():
    print(‘check func‘)


func_dic={
    ‘select‘:select,
    ‘delete‘:delete,
    ‘change‘:change,
    ‘add‘:add,
    ‘check‘:check,
}


while 1:
    inp=input(‘>>: ‘).strip()
    if not inp:continue
    cmd_l=inp.split()
    # print(cmd_l)
    cmd=cmd_l[0]
    if cmd in func_dic:
        func_dic[cmd](cmd_l)
    else:
        print(‘无效的命令‘)