pyhton的函数

目录

• 一、函数引入
• 二、函数的定义
• 三、如何定义一个函数
• 四、定义函数的三种形式
  • 1、空函数
  • 2、有参函数
  • 3、无参函数
• 五、函数的调用
• 六、函数的返回值
• 七、函数的参数
  • 1、形参
    • 1.1 位置形参
    • 1.2 默认形参
  • 2、实参
    • 2.1 位置实参
    • 2.2 关键字实参
• 八、可变长参数
  • 1、可变长形参
  • 2、可变长实参
  • 3、*形参
  • 4、**形参
  • 5、*实参（仅作了解）
  • 6、**实参（仅作了解）
• 九、函数对象
• 十、函数嵌套
• 十一、名称空间和作用域
  • 1、名称空间
    • 1.1 内置名称空间
    • 1.2 全局名称空间
    • 1.3 局部名称空间
  • 2、作用域
    • 2.1 全局作用域
    • 2.2 局部作用域
    • 2.3 局部作用域的特点
  • 3、名称空间的执行（生成）顺序
  • 4、搜索顺序

一、函数引入

函数其实就是一种工具，和你敲钉子用的锤子没有任何区别

你在用锤子敲钉子的时候首先需要有一把锤子，使用函数也是一样，你需要先定义一个函数，才能使用这个函数。

你定义了一个函数，需要使用它的时候只需要叫他的名字就行了。比用锤子方便多了。

二、函数的定义

什么是函数？

函数就是一种工具

三、如何定义一个函数

def 函数名():
    '''对函数（工具）的描述信息'''
    代码块

函数定义过程中，只检测语法，不执行代码

调用阶段，才会执行代码

四、定义函数的三种形式

1、空函数

def func():
    '''空函数就是只有pass的函数，没有代码，更没有参数'''
    pass

2、有参函数

def guess(x,y):
    '''给定两个数，打印较大的数'''
    if x > y:
        return x
    else:
        return y
# 通俗的说，就是括号内有东西，这些东西就是参数，他们本质上是一些变量名

3、无参函数

def guess():
    '''给定两个数，打印较大的数'''
    x = 30
    y = 20
    if x > y:
        return x
    else:
        return y
# 通俗的说，就是括号内没东西，就是没有参数

五、函数的调用

函数的调用就是使用函数，只需要直接调用函数的函数名就可以了

def guess():
    """给定两个数，打印较大的数"""

    x = 20
    y = 30
    if x > y:
        print(x)
    else:
        print(y)

 guess()  # 这里就把函数成功调用了

六、函数的返回值

返回值：就是返回一个值（可以是所有数据类型），就是指return后面的内容

def guess():
    """给定两个数，打印较大的数"""
    # return
    # print(1)
    x = 20
    y = 30
    if x > y:
        # print(x)
        return x
    else:
        # print(y)
        return y

return的特性：

1. return 返回一个返回值，如果没有返回值，返回None
2. 没有return 默认返回None
3. return 会终止函数，不运行下面的代码，假设有多个return的时候，运行到第一个就会结束，不会运行第二个
4. return 通过逗号隔开，可以返回多个值，返回值以元组的形式接收

七、函数的参数

1、形参

定义函数阶段的产物，具有接收实参的作用，具有描述意义

1.1 位置形参

从左到右依次接收实参的值

1.2 默认形参

1. 如果你不给，使用默认值；如果调用的时候传值，使用传的值
2. 默认形参必须得放在位置形参后面

2、实参

调用阶段的产物，传给形参一个具体的值，具有具体的值（可以为所有数据类型）

2.1 位置实参

从左到右依次给位置形参传值，一一对应，形参有多少个，实参也必须有多少个

2.2 关键字实参

1. 关键字实参必须写在位置实参的后面
2. 按照形参名给形参传值（使用情况，基本为0）---》函数的参数一般0-3个，尽量不要超过3个

八、可变长参数

1、可变长形参

形参中的会将溢出的位置实参全部接收，然后存储元组的形式，然后把元组赋值给 * 后的参数。需要注意的是：后的参数名约定俗成为args。

def sum_self(*args):
    res = 0
    for num in args:
        res += num
    return res

res = sum_self(1, 2, 3, 4)
print(res)

#  10

2、可变长实参

实参中的 * ,*会将 *后参数的值循环取出，打散成位置实参。以后但凡碰到实参中带 *的，它就是位置实参，应该马上打散成位置实参去看。 *,相当于做了解压缩，也就是把lt内的元素一个一个取出来传给形参。

def func(x, y, z, *args):
    print(x, y, z, args)

func(1, *(1, 2), 3, 4)

#  1 1 2 (3, 4)

3、*形参

调用函数时，用元组接收多余的位置实参

def f1(*args):  # 一般约定俗成用args来做*形参的变量名
    print(args)

f1(1, 2, 3, 3, 4, 5, 5, 6, 7, 7, 7, 7, 7, 7, 7, )

# (1, 2, 3, 3, 4, 5, 5, 6, 7, 7, 7, 7, 7, 7, 7)

4、**形参

调用函数时，用字典接收多余的关键字实参

def f1(**kwargs):  # 一般约定俗成用kwargs来做*形参的变量名
    print(kwargs)

f1(x=1)

# {'x': 1}

5、*实参（仅作了解）

传参时，把列表中的元素打散成位置实参然后依次传给位置形参

def f1(a, b, c, e, d, f, g):
    print(a, b, c, e, d, f, g)

lt = [1, 2, 3, 4, 5, 6, 7]
f1(*lt)

#  1 2 3 4 5 6 7

6、**实参（仅作了解）

传参时，把字典中的元素打散成关键字实参然后依次传给位置形参

def f1(z, b):
    print(z, b)

dic = {'z': 1, 'b': 2}  # a=1,b=2
f1(**dic)

# 1 2

九、函数对象

python中一切皆对象

函数也是一种对象

函数对象 = 函数名

函数名+() 就是在调用，就是在调用

1. 引用（拷贝）

   def f1():
       print('from f1')  
   
   func = f1
   print('f1:', f1)
   print('func:', func)
   
   func()
   

2. 容器元素

   def f1():
       print('from f1')
   
   lt = [f1, 1, 2, 3]
   
   print('lt[0]', lt[0])
   print('f1', f1)
   
   lt[0]()
   

3. 作为函数的实参

   def f1():
       print('from f1')   
   
   def f2(f2_f1):
       print('f2_f1',f2_f1)
       f2_f1()
   
   f2(f1)
   

4. 作为函数的返回值

   def f1():
       print('from f1')     
   
   def f2(f2_f1):
       return f2_f1
   
   res = f2(f1)  # 即res = f1
   print('res', res)
   print('f1', f1)
   
   res()
   

十、函数嵌套

函数嵌套 ：函数里面有函数

定义函数时，只检测语法，不会执行代码

函数内部定义的函数，外部不能用

十一、名称空间和作用域

1、名称空间

内存中专门用来储存名称的空间

1.1 内置名称空间

储存了内置方法的名称的空间

1.2 全局名称空间

除了内置和局部都叫全局

1.3 局部名称空间

函数内部定义的都叫局部

2、作用域

2.1 全局作用域

内置名称空间+全局名称空间 = 全局作用域

2.2 局部作用域

局部名称空间 = 局部作用域

2.3 局部作用域的特点

1. 全局作用域的 x 和局部作用域的 x 没有半毛钱的关系
2. 局部作用域1的x和局部作用域2的x也没有任何关系，即使局部作用域1和局部作用域2再同一个局部作用域下

3、名称空间的执行（生成）顺序

1. 内置名称空间：python解释器启动的时候就有了
2. 全局名称空间：执行文件代码的时候才会有全局
3. 局部名称空间：函数调用的时候才会有局部

4、搜索顺序

先从当前所在位置寻找，找不到再按照这种顺序，不会逆着方向寻找

局部 --》 全局 --》 内置 --》 报错