函数基础

Posted 2020-11-28 saoqiang

函数的初识

# 函数：以功能（完成一件事）为导向，登录，注册，len，一个函数就是一个功能。 随调随用。
# 减少代码的重复性。
# 增强了代码的可读性。

函数的结构与调用

定义一个函数
def len_num(a):
    return len(a)
b=len_num([123,1,2])
print(b)

# 结构：
#def 关键字，定义函数。
#len_num 函数名：与变量设置相同，具有可描述性。
#函数体 ：缩进。函数中尽量不要出现print
# return后面是返回值（len(a)） 在函数中遇到return直接结束函数。
    # return 将数据返回给函数的执行者，调用者 len_num()。
    # return 返回单个元素 是返回原有数据类型的形式返回
    # return 返回多个元素 是以元组的形式返回给函数的执行者。

函数的返回值

# return 将数据返回给函数的执行者，简单来说谁调用返回谁
# return 返回单个元素 是返回原有数据类型的形式返回
# return 返回多个元素 是以元组的形式返回给函数的执行者。

函数的参数

# 写一个函数，只接受两个int的参数，函数的功能是将较大的数返回。
# def compile(a,b): #行参  1.位置参数 2. 默认参数（经常使用的参数）
#     c = 0
#     if a > b:
#         return c
#     else:
#         return c
# compile(10,20)#实参 位置参数  关键字参数，
# 形参角度：
# 1. 位置参数
# 2. 默认参数  （经常使用的参数）

# 实参角度：
# 1. 位置参数 按照顺序，一一对应
# 2. 关键字参数， 一一对应
# 3. 混合参数：位置参数一定要在关键字参数的前面。

万能参数,仅限关键字参数

# 万能参数： *args, 约定俗称：args，
# 函数定义时，*代表聚合。 他将所有的位置参数聚合成一个元组，赋值给了 args。
# 写一个函数：计算你传入函数的所有的数字的和。
# def func(*args):
#     count = 0
#     for i in args:
#         count += i
#     return count
# print(func(1,2,3,4,5,6,7))
# **kwargs
# 函数的定义时： ** 将所有的关键字参数聚合到一个字典中，将这个字典赋值给了kwargs.
# 形参角度：仅限关键字参数 (了解) 可以在默认参数前也可以在后面 一定要传参数，不传报错
# 形参角度最终的顺序：位置参数,*args,默认参数，仅限关键字参数，**kwargs

# *的魔性用法
# **在函数的调用时，*代表打散。
def func(*args,**kwargs):
    print(args) # (1,2,3,22,33)
    print(kwargs)
# func(*[1,2,3],*[22,33])  # func(1,2,3,22,33)
# func(*'fjskdfsa',*'fkjdsal')  # func(1,2,3,22,33)
func(**{'name': '太白'},**{'age': 18})  #func(name='太白',age='18')

*的魔性用法。

# *在函数的调用时，*代表打散。
**{'name': '太白'}打散为name='太白' 
*[1,2,3]打散为1,2,3
# 函数外：处理剩余元素
# a,b,*c = [1,2,3,4,5]
# a,*c,b, = [1,2,3,4,5]
# a,*c = range(5)
# a,*c,b = (1,2,3,4,5,6)
# print(a,c,b)

名称空间作用域

# 内置名称空间：python源码给你提供的一些内置的函数，print input
# python分为三个空间：
    # 内置名称空间（builtins.py）
    # 全局名称空间（当前py文件）
    # 局部名称空间（函数，函数执行时才开辟）

# 加载顺序：
# 内置名称空间 ---> 全局名称空间  ----> 局部名称空间（函数执行时）
# 取值顺序（就近原则） 单向不可逆
# （从局部找时）局部名称空间  ---> 全局名称空间  --->  内置名称名称空间

# 作用域：
# 两个作用域：
    # 全局作用域 ：内置名称空间 全局名称空间
    # 局部作用域：局部名称空间（函数等）
# 局部作用域可以引用全局作用域的变量
# 局部作用域不能改变全局变量。 可以使用可以，不能改变
# 注意 python中不可以先引用 后定义

高阶函数

# 就是函数的嵌套
# 例1：
def func1():
    print('in func1')
    print(3)

def func2():
    print('in func2')
    print(4)

func1()
print(1)
func2()
print(2)
# in func1 3 1 in func2 4 2



# 例2：
def func1():
    print('in func1')
    print(3)

def func2():
    print('in func2')
    func1()
    print(4)

print(1)
func2()
print(2)


# 例3：
def fun2():
    print(2)

    def fun3():
        print(6)

    print(4)
    fun3()
    print(8)

print(3)
fun2()
print(5)

内置函数 globals locals

# 内置函数：globals locals
a = 1
b = 2
def func():
    name = 'alex'
    age = 73
    print(globals())  # 返回的是字典：字典里面的键值对：全局作用域的所有内容。
    print(locals())  # 返回的是字典：字典里面的键值对：当前作用域的所有的内容。
# print(globals())  # 返回的是字典：字典里面的键值对：全局作用域的所有内容。
# print(locals())  # # 返回的是字典：字典里面的键值对：当前作用域的所有的内容。
func()

global nonlocal

# global
# 1, 在局部作用域声明一个全局变量 声明后就可以修改全局变量

# nonlocal 存在于双层嵌套中
# 1. 不能够操作全局变量。
# 2. 作用局部作用域：内层函数对外层函数的局部变量进行修改。

函数名的应用

# 函数名是一个特殊的变量。
# 函数名指向的是函数的内存地址,加上()就执行这个函数。
# 3. 函数名可以作为容器类类型的元素。
# 4. 函数名可以作为函数的实参。
# 5. 函数名可以作为函数的返回值。

默认参数的坑

# 陷阱只针对于默认参数是可变的数据类型：
# 如果你的默认参数指向的是可变的数据类型，那么你无论调用多少次这个默认参数，都是同一个。
# 本质是闭包
# def func(name,alist=[]):
#     alist.append(name)
#     return alist
# ret1 = func('alex')
# print(ret1,id(ret1))  # ['alex']
# ret2 = func('太白金星')
# print(ret2,id(ret2))  # ['太白金星']

# 局部作用域的坑
# 在函数中，如果你定义了一个变量，但是在定义这个变量之前对其引用了，那么解释器认为：语法问题。
# 你应该在使用之前先定义。
# 列题
# count = 1
# def func():
#     count += 1
#     print(count)
# func()