函数

函数:将一些代码进行封装,减少重复代码

结构:

def 函数名():

　　函数体(代码块)

函数名+()         调用函数

函数的执行过程:

1.先定义 不会执行

2.调用 会执行定义好的语句

3.定义好的语句

return   

函数的返回值

不写return返回的是None

写了renturn不写值,返回的也是None

多个元素返回值都是元祖,可以返回任意数据

函数中当执行到return的时候就结束了,return以下代码全都不执行,并且终止函数

return的值返回给了调用者,想要查看的话直接打印调用者就可以

参数

定义的参数是形参   

调用的参数是实参

从实参到行参的过程叫传参

形参和实参的数量要一一对应

def func(addr,age)          #形参   addr是一个变量名 
    print(...)
    print(...)
func('北京',18)                #实参,和形参的变量名一一对应

实参划分:

位置参数       func('北京',18)                       和形参位置的顺序一一对应

关键字参数   func(addr='北京',age=18)      对关键字赋值,按照关键字进行传参,可以颠倒顺序

混合参数       func('北京',age=18)               顺序:位置参数要在关键字参数的前面

形参划分:

位置参数    def func(addr,age)                 和实参位置一一对应

默认参数    def func(age=18)                   相当于实参的关键字参数,按照关键字进行传参

混合参数    def func(addr,age=18)           顺序:位置参数在默认参数前面

动态参数

动态位置参数: *args

def func(*args)          聚合打包  获取到数据的是元祖的形式

def func(a,b,*args):
　　print(a,b,args)
func(1,2,3,4,5,6,7)


结果:
1 2 (3, 4, 5, 6, 7)


#当位置参数和动态位置参数一起使用时,要注意位置参数在动态位置参数的前面,不然没有值传参给位置参数,全部打包在*args里

打散:

def func(a,b,*args):
    print(a,b,*args)            #打散打印args
func(1,2,3,4,5,6,7)


结果:
1 2 3 4 5 6 7

#打印的时候写 *args  是将本来打包的数据打散之后再打印

def func(*args):
    print(args) 
func(*[1,2,3,4,5])     #将列表打散之后再传参给*args

结果:
(1, 2, 3, 4, 5)

动态关键字参数: **kwargs     

def func(*args)  获取到数据的是字典的形式

def func(**kwargs):
    print(kwargs) 
func(a=1,b=2,c=3)

结果:
{'a': 1, 'b': 2, 'c': 3}

在写参数的时候也要注意顺序: 关键字参数>动态关键字参数

打散:

def func(**kwargs):
    print(*kwargs)        #打散字典的键再打印,只写一个*就可以,写print(**kwargs)会报错
func(a=1,b=2,c=3) 

结果:
a b c

def func(**kwargs):
    print(kwargs)
func(**{'a':1,'b':2,'c':3})    #将字典打散传参

结果:
{'a': 1, 'b': 2, 'c': 3}

如果将上述几种参数一起使用的话,要遵守一定的顺序:

位置参数>动态位置参数>默认参数>动态默认参数

将动态位置参数和动态默认参数放在一起的话,就会形成万能的函数定义结构,也是最经常用到的:

def func(*args,**kwargs) 

函数的注释:

def func(*args,**kwargs):

打出'''   然后回车 就可以给函数添加注释

def func(*args,**kwargs):
    '''
    
    :param args: ...
    :param kwargs: ...
    :return: ...
    '''

print(func.__doc__) 查看函数的注释

函数的名称空间

内置空间

全局空间

局部空间

找值顺序:局部空间--全局空间--内置空间

加载顺序:内置空间--全局空间--局部空间

作用域名称空间:

内置空间+全局空间 == 全局空间

局部空间

python关键字是存在内置空间的

py文件中顶头写的内容存在全局空间

函数内写的变量存在局部空间 局部空间数据不能共享,是独立的

函数的嵌套:

def func():
    print(1)
def func1():
    print(2)
    func()
func1()           # 函数名+()不管在哪都是调用     调用的时候先定义后调用

结果:
2
1

def func():
    print(1):
    def func2():
        print(2)
    func2()
func()          #一层一层的找,同级也遵守从上到下的执行顺序

globals 查看全局作用域内容

locals 查看局部作用域内容 在哪个位置就查看哪个局部

global

a = 10
def func():
    global a     #声明要修改全局变量a的值
    a = 10
    print(a)
func()
print(a)

结果:
10
10

a = 10
def func():
    global b      #全局内没有变量b,会直接创建一个b,赋值为10
    b = 10
    print(a)
func()
print(a)

结果:
10
10

nonlocal

n = 1
def func():
    n = 10
    def func1():
        nonlocal n     #修改上一层的变量值,上一层没有就继续找再上一层,找到最外层局部,不可以使用全局变量
        n = 100
        print(n)
    func1()
func()
print(n)

结果:
100
1

和global不一样的是,当nonlocal要修改的变量在局部变量当中找不到时,会直接报错

补充知识:

三元运算符:
return x if x > y else y

如果x>y条件成立,返回x,不然就返回y