函数的名称空间和作用域

Posted 2020-11-23 bs2019

函数

一.什么是函数？

? -函数就是一种工具，可以重复调用

? -函数是先定义，后调用，在定义阶段只检测语法，不执行代码。

      1、什么是函数？
        def ：定义函数的关键字：define

        函数名：命名规范与变量名命名规范一致
            1、一定不要与关键字冲突
            2、一定要见名知意
        2.为什么要用函数？
            1.防止代码冗余
            2.代码的可读性差
         3.怎么使用函数？
            1.定义函数 ----制造函数
            2.调用函数-----使用函数
          4.函数的分类
            -无参函数
             def index():
            print('ok')
            
            -空函数
              def login():
            pass
            -有参函数
             def login(username):
            print(username)
 
 

二、函数返回值

? -不写return：默认返回None

def index():
    print('hello')
    return
index()
>>>>>>
hello

? -只写return：只有结束函数体代码的效果，返回None

? -写return None ：与只写return的效果相同

-return返回一个值：可以将返会的结果，当作一个变量值来使用

def home(a, b):
    if a > b:
        return a
    else:
        print(b)
        return b

res = home(2, 3)
print(res)
>>>>>
3
3

? -return返回多个值：

? -将返回的多个值，默认存到元组中返回；

? -函数返回值不想被修改；

? -可以自己指定返回的数据类型。

a = 1
b = 2
c = '3'
d = [4, 5]
e = {'name': 'sean'}
def func(a, b, c, d, e):
    return a, b, c, d, e
    # return [a, b, c, d, e]


print(func(a, b, c, d, e))
>>>>>>>>
(1, 2, '3', [4, 5], {'name': 'sean'})


可以指定return的数据类型
a = 1
b = 2
c = '3'
d = [4, 5]
e = {'name': 'sean'}
def func(a, b, c, d, e):
    # return a, b, c, d, e
    return [a, b, c, d, e]


print(func(a, b, c, d, e))
>>>>>>>>>>
[1, 2, '3', [4, 5], {'name': 'sean'}]

三、函数的参数

-形参：在函数定义阶段就规定的参数，它就相当于定义变量时的变量名

? -实参：是在函数的调用阶段传入的参数，它相当于定义变量时的变量值

# python代码从上到下依次执行
def index(a):  # 形参'a:相当于变量名
    
    print(a)
    print(b)
if a > b:
    print(a)
else:
    print(b)


a = 1
index(a)  # 实参：a相当于变量值
b = 2

传参的方式

1.位置参数

? -通过位置进行传参

def index(a, b):
    print(a, b)
index(2, 3)
>>>>>>>
2 3

2.关键字传参

? -指定参数进行传参

? -位置参数一定一定要在关键字参数之前，连用的时候，不要对同一个形参重复赋值

def index(a, b, c, d):
    print(a, b, c, d)
index(1,  2, c = 3, d = 4)#####关键字参数一定要在位置参数的后面
>>>>>>>
1 2 3 4

#####           3.默认参数

? -在定义函数阶段就已入参数，

? 如果你在实参的时候传入一个新的参数，就会使用新的参数，默认的参数在传值的 时候，不要将可变类型党当作参数传入。

? 应用场景：

? -当参数对应值重复出现的情况下使用默认值。

def  index(username, age , gender = 'male'):###第三个变量就是默认参数
    print(f'{username}: {age}: {gender}')
index('egon', '20')
index('David', 20,)
index('lily',20, 'female')
>>>>>
egon: 20: male
David: 20: male
lily: 20: female
        
 另外的例子
def home(hobby, l1 = None):
    if l1 == None:
        l1 = []
    l1.append(hobby)
    print(f'爱好{hobby}')
    print(l1)
home('aaaa')
home('asf')
home(hobby = 'shenfhao')
>>>>>>>>>>>>>>
爱好aaaa
['aaaa']
爱好asf
['asf']
爱好shenfhao
['shenfhao']

可变的参数不要当作参数传入 真正的去传入一个可变的参数，也有返回值，但是尽量不要去这样操作
def  index(username, age , gender = 'male'):
    print(f'{username}: {age}: {gender}')
index('egon', '20')
index('David', 20,)
index('lily',20, ['female','male'])###['female',  'male']变颜色
>>>>>>>>>>>
egon: 20: male
David: 20: male
lily: 20: ['female', 'male']#####打印结果 ，没有问题

4、可变长参数

? *args：接收所有的溢出的位置参数，接收的值都是被存入一个元组。

? -官方认证的是args 也可以其他的命名，但是 必须要带

? -只要有* 就有可变长参数的效果

?

? * 打散就是传入容器类型

? -**kwargs :接收所有的溢出的关键字参数，接收的值都被存入在一个 字典。

? -官方认证的是**kwargs

 * 在函数定义阶段：接收所有溢出的位置参数，将接受的值以元组的形式传入* 后面的变量中
                    * 在函数调用阶段：将列表、元组、字符串、集合等可以使用的for循环的容器类型打散成位位置参数

                    ** 在函数定义阶段：接收所有溢出的关键字参数，将接受的值以字典的形式传入** 后面的变量中
                    ** 在函数调用阶段：将字典打散成关键字参数传入形参

def index(a,b, *args ):####这个是在的定义阶段 传入后面的元组
    print(a,b,args)   #####不要带星号 不然后面的返回的不是元组
index(1, 2, 3, 4, 5)
>>>>>>>>
1 2 (3, 4, 5)

def index(a, b, c, d):
    print(a, b, c, d)
index(1, 2, *[3, 4])
>>>>>>>>>
1 2 3 4

def func(a,b,c,**kwargs):####**后面返回的是字典
    print(a,b,c,kwargs) ####打印的时候一定是这种不带***的
func(1,2,c = 3,d = 5, f = 6)
>>>>>>>>>>
1 2 3 {'d': 5, 'f': 6}

def func(a,b,c,**kwargs):
    print(a,b,c,*kwargs)#####打印的是一个*的  打印结果是key
func(1,2,c = 3,d = 5, f = 6)
>>>>>>>>>>>>>
1 2 3 d f

** kwargs的

ef bar(a, b, c, d, e, f):####
    print(a, b, c, d, e, f)

bar(1, 2, 3, d=10, e=20, f=30)
>>>>>>>>
1 2 3 10 20 30
下面的是用**kwargs的方法
def bar(*args, **kwargs):#####可以接收位置参数和关键字参数
    print(args, kwargs) #####打印的不要带* ，* kwargs 打印出来的是字典的key
bar(1, 2, 3, d=10, e=20, f=30)
>>>>>>>>>>>
(1, 2, 3) {'d': 10, 'e': 20, 'f': 30}

定义在* 和** 之间的

再给命名关键字传值的时候 一定要以关键字的形式传递

def index(x, y, z, *args, a=1, b, **kwargs):
        print(x, y, z)
        print(args)
        print(a, b)
        print(kwargs)
index(1, 2, 3, 354353, 4342, 3213123, a=111, b=222, c=333, d=444)
>>>>>>>>>
1 2 3
(354353, 4342, 3213123)
111 222
{'c': 333, 'd': 444}