一、函数

1、什么是函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

作用：

函数能提高应用的模块性，和代码的重复利用率。

2、函数的语法结构

def 函数名(参数):

‘’‘函数注释’’’

函数体代码

return 返回值

1.def

定义函数的关键字

2.函数名

等同于变量名

3.参数

可以不填，主要是在使用函数的时候规定外界要不要传数据进来

4.函数注释

类似于说明书，用来介绍这段函数体的使用说明

5.函数体代码

是整段函数的核心，主要取决于程序员的编写

6.return

使用函数之后可以返回数据给使用者，可以不填

3、函数的定义与调用

1.函数在定义阶段只检测语法，不执行代码

def func():

pass

2.函数在调用阶段才会执行函数体代码

func()

3.函数必须先定义，后调用

4.函数的调用使用:函数名()

如有参数需要在括号内按相应的规则填写

4、函数的分类

1.空函数

函数体代码为空，主要用于先创建一个框架，函数体用pass补全

def register():

“”“注册功能”""

pass

2.无参函数

函数名后方括号内无需填写参数

def index():

print(‘from index function’)

3.有参函数

函数名后方括号内需要填写参数才可以调用

def func(a):

print(a)

5、函数的返回值

1.什么是返回值

调用函数之后返回给调用者的结果

2.如何获取返回值

# 变量名 赋值符号 函数的调用

res = func() # 先调用函数，然后用变量名接收结果

3.返回值的多种结果

1.函数体代码中没有return时，默认返回None

2.函数体代码中有return时，后面没写数据，返回None

3.函数体代码中有ruturn时，返回后面写的值

4.函数体代码中有return时，后面写多个数据，以元组的形式返回

我们以list形式写的值就会以列表返回，否则默认以元组形式返回

5.函数体代码遇到retrun会自动结束函数体代码

6、函数的参数

1.形式参数

在函数定义阶段函数名后方括号内填写的参数，简称‘形参’

2.实际参数

函数调用时，函数名后方括号内填写的参数，简称‘实参’

‘’’

形参与实参的关系：

形参类似于变量名，在函数定于阶段可以随便写，最好做到见明知意

def register(name,pwd):

pass

实参类似于数据值 在函数调用阶段与形参临时绑定 函数运行结束立刻断开
register('kangkang',123)   形参name与kangkang绑定 形参pwd与123绑定

‘’’

二、函数参数

参数分为两种：

1、形参

2、实参

而形参和实参又共分为以下几个种类

1、位置参数

1.位置形参：

在函数定义阶段括号内从左往右依次填写的变量名

def func(a, b, c):pass

2.位置实参：

在函数调用阶段括号内从左往右依次填写的数据值

func(1, 2, 3)

定义：

1、在调用时，形参和实参位置必须一致

2、在调用时，形参和实参数量必须一致

3、在调用时可用关键字传参

3.1.关键字传参需要跟在位置传参的后面

4、同一个形参在调用时不能多次赋值

5、实参可以传递绑定数据值的变量名

案例一：在下面这个函数中， a 是必选参数，是必须要指定的

>>> def demo_func(a):
...     print(a)
... 
>>> demo_func(10) 
10
>>> demo_func()  # 不指定会报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: demo_func() missing 1 required positional argument: 'a'

案例二：在下面这个函数中， name 和 age 都是必选参数，在调用指定参数时，如果不使用关键字参数方式传参，需要注意顺序

>>> def print_profile(name, age):
...     return f"我的名字叫{name}，今年{age}岁了"
...
>>> print_profile("kangkang", 18)
'我的名字叫kangkang，今年18岁了'

如果参数太多，你不想太花精力去注意顺序，可以使用关键字参数方式传参，在指定参数时附上参数名，比如这样：

>>> print_profile(age=18, name="kangkang")
'我的名字叫kangkang，今年18岁了'

2、默认参数

1.默认形参

在函数定义阶段，可填写默认值

def func(name, age = ‘18’)

2.默认实参

在调用阶段，默认值不需要修改时可以不用传参，结果为默认值

def func(‘kangkang’)

定义：

默认参数必须放在位置参数的后面，否则程序会报错

案例一：在下面这个函数中，b 是可选参数（默认参数），可以指定也可以不指定，不指定的话，默认为10

>>> def demo_func(b=10):
...     print(b)
... 
>>> demo_func(20)
20
>>> demo_func()
10

案例二：在定义时，必选参数一定要在可选参数的前面，不然运行时会报错

>>> def demo_func(a=1, b):
...     print(a, b)
... 
  File "<stdin>", line 1
SyntaxError: non-default argument follows default argument
>>>
>>> def demo_func(a, b=1):
...     print(a, b)
... 
>>>

3、可变长参数

1、一个*号

1.可变长形参 * （一个*号）

在函数定义阶段，括号内的参数可接收多余位置实参，*后的参数名约定俗成为args

def num (x,y,*args):

print(args)

return 1

num(1,2,3,4,5)

(3, 4, 5) *args就为（3,4,5），1,2分别传给了x,y

2.可变长实参 * （一个*号）

在函数调用阶段，*可接收各类数据库并循环进行传参

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

print(x, y, z, args)

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

1 1 2 (3, 4)

‘’’

须知：

1.字符串 # 按字符顺序依次传参

2.列表 # 按列表数据值顺序依次传参

3.集合 # 集合无序，数据值传参顺序随机

4.元组 # 按元组数据值顺序依次传参

5.字典 # 只能传参字典K值

‘’’

案例一：在下面这个函数中，args 参数和上面的参数名不太一样，在它前面有一个 *，这就表明了它是一个可变参数，可以接收任意个数的不指定参数名的参数。

>>> def demo_func(*args):
...     print(args)
... 
>>> 
>>> demo_func(10, 20, 30)
(10, 20, 30)

案例二：可变位置参数可以放在必选参数前面，但是在调用时，必选参数必须要指定参数名来传入，否则会报错

>>> def demo_func(*args, b):
...     print(args)
...     print(b)
... 
>>> demo_func(1, 2, 100)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: demo_func() missing 1 required keyword-only argument: 'b'
>>> 
>>> demo_func(1, 2, b=100)
(1, 2)
100

2、两个*号

1.可变长形参 **  （两个*号）
  会将溢出的关键字实参，储存成字典的形式，然后赋值给**号后的形参，**号后参数约定俗成，称为kwargs
    def func(**kwargw):
        print(kwargw)
     func(a=5)
----------------------------------------------------------
{'a': 5}
2.可变长实参 **  （两个*号）
   将字典打散成关键字参数的形式传递给形参
    def func(name, age, hobby):
      print(name, age, hobby)
    dict_user_name = {'name': 'kangkang', 'age': 18, 'hobby': 'ball'}
      func(**dict_user_name)
----------------------------------------------------------
kangkang 18 ball   

案例二：在下面这个函数中，kw 参数和上面的 *args 还多了一个 * ，总共两个 ** ，这个意思是kw 是一个可变关键字参数，可以接收任意个数的带参数名的参数。

>>> def demo_func(**kw):
...     print(kw)
... 
>>> demo_func(a=10, b=20, c=30)
{'a': 10, 'b': 20, 'c': 30}

案例三：可变关键字参数则不一样，可变关键字参数一定得放在最后，下面三个示例中，不管关键字参数后面接位置参数，还是默认参数，还是可变参数，都会报错。

>>> def demo_func(**kw, a):
  File "<stdin>", line 1
    def demo_func(**kw, a):
                        ^
SyntaxError: invalid syntax
>>> 
>>> def demo_func(**kw, a=1):
  File "<stdin>", line 1
    def demo_func(**kw, a=1):
                        ^
SyntaxError: invalid syntax
>>> 
>>> def demo_func(**kw, *args):
  File "<stdin>", line 1
    def demo_func(**kw, *args):
                        ^
SyntaxError: invalid syntax

3、*args和**kwargs一起使用

def num(x, y, f=0, *args, **kwargs):
    print(f)
    print(args)
    print(kwargs)
    return 1
num(1, 2, 6, 7, 8, j=3, n=4, q=5)
---------------------------------------------------------------------------
6
(7, 8)
{'j': 3, 'n': 4, 'q': 5}

案例一：在定义时，可变位置参数一定要在可变关键字参数前面，不然运行时也会报错

>>> def demo_func(**kw, *args):
  File "<stdin>", line 1
    def demo_func(**kw, *args):
                        ^
SyntaxError: invalid syntax
>>> 
>>> def demo_func(*args, **kw):
...     print(args, kw)

三、名称空间

1、名称空间的类型、作用及存活时间

内置名称空间

作用：用来储存python解释器内置方法名的空间

作用域：python解释器

存活周期：解释器开启则产生，关闭则销毁

全局名称空间

作用：用来储存py文件内变量名的空间

作用域：单个py文件

存活周期：单个py文件打开时产生，关闭则销毁

局部名称空间

作用：用来储存函数体代码内变量名的内存空间

作用域：函数体代码、类别体代码

存活周期：函数体、类别体代码运行时产生，运行完毕销毁

2、名字的查找顺序

首先，在查找前，我们需要分请名字所在的域

python运行代码时由外部代码向内运行，而名字则是由内向外查找：

局部内存空间

局部内存空间>>>全局内存空间>>>内置内存空间

全局空间

全局内存空间>>>内置内存空间

且要符合以下几点要求：

1、在局部内存空间嵌套，由子代码向父代码中查找

2、相互独立的代码体默认无权互相访问