python基础九之函数

　　1，函数的定义

　　函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数分为自定义函数和内置函数，内置函数就是python内部自带的一些函数，如：print()、int()等。自定义函数是我们自己为了完成某个功能而自己写的函数。

def func():    # 自定义函数

    print('zxc')

"""

    def关键字+函数名：

        函数体

    函数名的命名规则和变量的一样

    函数体就是完成功能的代码

"""

　　2，函数的调用

　　函数名()即可调用函数。

def func():    # 自定义函数

    print('zxc')

# 函数的调用

func()  # 运行结果打印了zxc

　　3，函数的返回值

　　为了使用函数运行后的一些数据，我们需要函数调用后能够返回这些数据，所以就要定义返回值！

　　定义返回值的关键字是return

　　　　1，没有return和只有return，调用函数后返回None

# 函数的返回值

def re():

    s = 'zxc'

print(re())  # None

def re():

    s = 'zxc'

    return

print(re())  # None

　　　　2，return加一个返回值的，通过变量=函数名()可以获取返回值

def re():

    s = 'zxc'

    return s

s1 = re()

print(s1)   # zxc

　　　　3，return加多个返回值的，通过一个或对应个数的变量来接收

　　　　　　一个接收的是所有返回值组成的一个元组

　　　　　　多个接收要对应返回值的个数，一一对应赋值

def re():

    s = 'zxc'

    s1 = ''

    return s, s1

a = re()   # ('zxc', '123')赋值给a

x, y = re()  # zxc和123分别赋值给x和y

# z, b, c = re()   # 接收和返回的不对应 报错！

print(a)

print(x, y)

　　　　ps：在函数体中遇到return就会结束函数！

def re():

    s = 'zxc'

    return s   # 遇见return就结束函数

    print('')

print(re())   # 返回zxc 但是123不会打印

　　4，函数的参数

　　函数的参数分为形参和实参

def func(s):  # s为形式参数  形参

    print(s)

func('zxc')  # zxc为实际参数  实参

　　　　以实参来看，只有两种，按位置进行传参和按关键字进行传参

def func(x, y, z):

    print(x)

    print(y)

    print(z)

# 以实参来看

func(1, 2, 3)  # 按位置进行传参  传递的参数个数必须要对应

func(y=2, x=1, z=3)  # 按照关键字进行传参 无须考虑位置关系

func(1, z=3, y=2)  # 在先按照位置传参的前提下后面的参数可以按照关键字进行传参

# func(x=1, 2, 3)  # 按关键字传参不能放在最前  报错

　　　　以形参来看，分为四种，位置参数、*args、默认参数、**kwargs

def func(s, *args, default = '默认值', **kwargs):

    print(s)             #

    print(args)          # ('a', 'b', 'c')

    print(default)       # 默认值

    print(kwargs)        # {'s1': '123', 's2': '456'}

func(1, 'a', 'b', 'c', s1='', s2='')

l = ['a', 'b', 'c']

d = {'s1': 123, 's2': 456}

func(1, *l, **d)   # 列表和元组加上*号可将其按顺序打散进行传参，字典加上**

"""

    s 接收位置参数 有必须传

    *args 动态参数 接收任意多个位置参数 将其组合为元组接收

    default = '默认值' 默认参数 没有实参就='默认值'

    **kwarges 动态参数 接收任意多个关键字参数  将其组合为字典接收

    几种形参的先后顺序：

        位置参数，*arges，默认参数，**kwarges

"""

　　　　默认参数的陷阱

def func(li=[]):

    li.append(1)

    return li

print(func())   # [1]

print(func())   # [1, 1]

print(func([1, 2]))   # [1, 2, 1]

print(func())   # [1, 1, 1]

# 如果函数的默认参数的值是可变数据类型，不传参数多次调用将公用同一个值

　　5，函数的命名空间和作用域

    内置命名空间，全局命名空间和局部命名空间
    内置命名空间：python解释器加载时创建的命名空间，用于储存内置的一些数据名字和函数名字
    全局命名空间：我们的代码从上到下运行时，将我们用到的命名储存起来的空间
    局部命名空间：用于储存函数内部的命名的空间，函数调用时才会创建，结束时会消失

　　　　命名空间

# 命名空间

a = 1

def func():

    b = 2

    def inner():

        c = 1

        print(a, b)  # print在内置命名空间中，a在全局命名空间中，b在局部命名空间中

    inner()

    # print(c)   # 报错   c在inner函数的命名空间中

    print(a)

func()

# print(b)  # 报错    b在func函数的命名空间中

"""

    通过上面的例子可以看出：内置命名空间 > 全局命名空间 > 局部命名空间

        命名空间不能向下访问，只能向上访问！

"""

　　　　作用域

# 作用域

"""

    全局作用域和局部作用域

    全局作用域：内置命名空间和全局命名空间中的都属于全局作用域 -- globals()获取全局作用域的内容

    局部作用域：函数中的局部命名空间 -- locals()获取本地作用域的内容

"""

a = 1

c = 0

def func():

    b = 1

    def inner():

        global a     # 使a在局部的操作能够作用于全局

        a += 1

        nonlocal b    # 使b在局部的操作能够作用于上一层

        b += 1

    inner()

    print(b)   #

    # nonlocal c   # 报错  说明nonlocal不能使局部的操作作用于全局

    # c += 1

func()

print(a)   #

　　6，函数的嵌套

　　　　函数的嵌套调用

# 函数的嵌套调用

def func():

    print('zxc')

def func1():

    func()

func()

# 在函数内部可以使用外部的已经定义好的函数

　　　　函数的嵌套

# 函数的嵌套

def func():

    def inner():  # 嵌套

        print('zxc')

# inner()    # 报错

#  外部不能直接调用函数内部嵌套的函数

　　　　函数名的本质：一串内存地址

"""

    函数名：第一类对象

        1，函数名可以赋值

        2，函数名可以作为容器类型的元素

        3，函数名可以是参数和返回值

"""

def func():

    print('zxc')

ret = func   # 赋值

ret()    # zxc

def func():

    print('zxc')

def func1():

    print('zxf')

li = [func, func1]  # 容器类型的元素

for i in li:

    i()    # zxc zxf

def func():

    print('zxc')

    return func   # 返回值

def inner(f):

    f()

ret = func()

ret()

inner(func)    # 参数

　　7，闭包

# 闭包

def func():

    a = 1

    def inner():

        print(a)

    return inner

ret = func()

ret()

"""

    在嵌套的内部函数中调用了外部函数的变量就会形成一个闭包。

    功能： 当调用这个函数时，形成闭包调用的外部变量会专门保存到内存中，不会在函数结束是清除，

           以便在多次调用时节省重复创建变量的时间。

"""

巴特西

python基础九之函数

最新文章

热门文章