函数使用（函数定义及调用方式、传参与返回参数、命名空间、装饰器）

函数定义及调用方式

一. 定义函数
1. 自定义函数的规则

    • 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
    • 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
    • 函数的第一行语句可以选择性地使用文档字符串（docstring），用于存放函数说明。
    • 函数内容以冒号起始，并且缩进。
    • return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回             None。

定义函数使用 def 关键字，一般格式如下：

def 函数名（参数列表）:
       函数体

    • 关键字 def：标志着函数头的开始
    • 函数名（function_name）：唯一标识一个函数，函数命名遵循标识符的编写规则。
    • 参数（parameters）：通过它可以将值传递给函数，是可选的。
    • 冒号（:）：用于标记函数头的结尾。
    • 文档字符串（docstring）：用于描述函数的功能，是可选的。
    • 函数体：由一个或多个有效的 python 语句构成，语句必须具有相同的缩进级别（通常为 4 个        空格）。
    • return 语句：用于从函数返回一个值，可选的。
    • 函数头后的第一个字符串称为 docstring（文档字符串 - documentation string 的缩写），用于        简单地解释函数的功能，可以使用 function_name.__doc__ 来访问。

 
二. 调用函数

一旦函数被定义，便可以从另一个程序、函数、甚至是 Python shell 中调用它。

要调用函数，只需键入函数名称，以及适当的参数。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
#定义函数
def area(width, height):
    '''计算面积函数'''
    return width * height
 
 
w = 4
h = 5
 
print("width =", w, " \nheight =", h)
 
# 调用函数
print( " \narea =", area(w, h))
 
# 访问文档字符串
print(area.__doc__)

传参与返回参数

函数传参

空参数
定义函数时括号里面没有形参，调用时不用传参。

def func():
    print('null para.')
 
# 调用
func()

位置传参
规定形参的数量，调用时必须传递相同数量的形参。

def func(a, b):
    print(a,b)
 
# 调用
func(11, 22)

带默认参数的形参
带默认值的参数位于非默认值参数的后面， 即位于位置参数，可变参数后面。

def func(a, b, c=0):
    print(a, b, c)
 
# 调用
func(11, 22)

传递元组型可变参数

def f2(a, b, *args):
    print(a)
    print(b)
    print(args)
 
rest =  f2(10, 20, 30, 40, 50)
print(rest)

执行结果：
10
20
(30, 40, 50)

元组传参传递的另一种方式：

def f2(a, b, *args):
    print(a)
    print(b)
    print(args)
 
my_tuple = (30, 40, 50)
rest =  f2(10, 20, *my_tuple)
print(rest)

执行结果：
10
20
(30, 40, 50)
 
除位置参数10, 20以后的数据自动赋值给了元组形参*args
如果只传10,20这2个参数给f2函数也不会报错，此时元组接收的参数为空。

传递字典型可变参数

def f2(a, b, **kwargs):
    print(a)
    print(b)
    print(kwargs)
 
rest =  f2(10, 20, ka=558, kb='bbb')
print(rest)

执行结果：
10
20
{'ka': 558, 'kb': 'bbb'}

传递字典参数的另一种形式：

def f2(a, b, **kwargs):
    print(a)
    print(b)
    print(kwargs)
 
kw_para = {'ka': 558,' kb': 'bbb'}
 
rest =  f2(10, 20, **kw_para)
print(rest)

执行结果：
10
20
{'ka': 558, 'kb': 'bbb'}

位置参数、元组参数、字典参数混合传参

def f2(a, b, *args, **kwargs):
    print(a)
    print(b)
    print(args)
    print(kwargs)
 
my_kw = {'ka': 558, 'kb': 'bbb'}
my_tuple = (30, 40, 50)
rest =  f2(10, 20, *my_tuple, **my_kw)
print(rest)

结果：
10
20
(30, 40, 50)
{'ka': 558, 'kb': 'bbb'}
按位置参数、元组参数、字典参数的顺序定义函数和调用，位置顺序不能调换！
除非有带默认参数的位置参数，此时带有默认参数的位置参数需要放到元组参数和字典参数之间。

带有默认参数的位置参数、元组参数、字典参数混合传参

def f2(a, *args, b=0, **kwargs):
    print(a)
    print(b)
    print(args)
    print(kwargs)
 
my_kw = {'ka': 558, 'kb': 'bbb'}
my_tuple = (30, 40, 50)
rest =  f2(10, *my_tuple, **my_kw)
print(rest)

结果：
10
0
(30, 40, 50)
{'ka': 558, 'kb': 'bbb'}

函数返回值

• 函数执行完不出现return语句，或者return语句不返回值，此时调用者收到的返回值为None。
• 可以返回一个元组。

def func():
    return 1, 2, 3
 
x, y, z = func()

     • 返回其他对象等。

变量：

返回一个数据

def text()
a = 3
return a 

- 返回一个元组(也就是返回多个参数，只不过以元组方式返回)

def measure():
	测量温度和湿度"""
		temp = 20
		sd = 30
返回一个元组的时候，可以不用括号
return temp, sd

 

    接收元组的时候，通过返回值result = measure（）
    或者通过索引获取响应的值。result[0]通过这个获取第一个值
    或者通过多个变量接收返回值。

 由此推广一个两个数交换的方法

#python 专有的
a = 10 
b = 20 
a, b =  b, a

列表中的extend与列表的“+=”一样

extend() 方法语法：
L.extend(iterable)

L = ['Google', 'Runoob', 'Taobao']
L.extend('12') # 可迭代对象是字符串
L.extend([3,4]) # 可迭代对象是列表
L.extend((5,6)) # 可迭代对象是元祖
L.extend({7:'seven',8:'eight'}) # 可迭代对象是字典(默认是键)
![在这里插入图片描述](https://img-blog.csdnimg.cn/20200127163146551.png)
在python中，列表变量调用
“+= ”本质上是在执行列表变量的 extAnd方法，不会修改变量的引用

命名空间

名称空间: 保存名字用的
变量, 函数, 类

1. 内置名称空间:python自己, print, input, len
2. 全局名称空间: 你写的代码从上到下
3. 局部名称空间: 函数, 类, 方法, 其他模块, 对象

    • 命名空间实际上就是一个字典，是一个专门用来存储变量的字典
    • locals()用来获取当前作用域的命名空间
    • 如果在全局作用域中调用locals()则获取全局命名空间，如果在函数作用域中调用locals()则获       取函数命名空间
    • 返回值是一个字典
    • globals() 可用来获取全局作用域的命名空间。
     需要注意的是，此全局变量不是指所有定义过的变量，而是指全局作用域的变量，不含所有         局部变量。初学者容易在这里顾名思义而走入误区。
    • 将locals()写在全局作用域的位置，也可以获取到全局作用域的命名空间。

a = 1
b = 2
c = 3
d = 4


def fun():
    a = 5
    b = 6
    e = locals()  # 获取局部作用域的命名空间 
    f = globals()  # 获取全局作用域的命名空间 

    print(e)  # 得到的结果为{'b': 6, 'a': 5}
    print(f)   # 得到的结果中'a': 1, 'b': 2, 'c': 3, 'd': 4, 'fun': <function fun at 0x000001FE90B61EA0>}等一些本地自带的变量......
    pass

fun()

s = locals()  # 获取当前作用域的所有变量，并且以一个字典的形式返回出来
print(s)   # 结果同上边的 f

装饰器

定义：在代码运行的期间动态的增加功能的方式我们称之为装饰器

一·装饰器的引入

我们可以直接通过修改函数中的代码来完成需求，但是会产生以下一些问题：
1.如果修改的函数多，修改起来会比较麻烦。
2.不方便后期的维护。
3.这样做会违反开闭原则(ocp)
• 程序的设计，要求开发对程序的扩展，要关闭对程序的修改
装饰器示例：

def fun(fn, *args):
    print('函数开始执行')
    r = fn(*args)
    print(r)
    print('函数执行结束')

二·装饰器的使用

• 通过装饰器，可以在不修改原来函数的情况下来对函数进行扩展。
• 在开发中，我们都是通过装饰器来扩展函数的功能的。
• 装饰器是一个特殊的闭包函数

这里写一个功能为 验证登录 的装饰器函数：

# 加入说这个装饰器是一个验证登录的装饰器
def old_fun(a):

    def new_fun(*args, **kwargs):  # 不定长参数， 不管你传多少参数，\
    或者你传不传参数，我这个不定长参数都可以保证代码不会出错
        print('函数开始执行')
        # print(a())
        a(*args, **kwargs)
        print('函数执行结束')

    return new_fun

装饰器语法糖写法：

@old_fun     # 装饰器的语法糖写法:  @old_fun =   'r = old_fun(fun)
def fun():
    print('我是fun函数')
    # return '我是fun函数'

fun()

执行结果：

注意：
1.使用内函数来接收被装饰函数的参数
2.调用被装饰的函数的时候，需要将参数传递进去。