1.形参的调用方式

1. 位置参数调用

2. 关键词参数调用

原则： 关键词参数调用不能写在位置参数调用的前边

def test1(name, age):print("name:", name)print("age:", age)if "__main__" == __name__:test1("admin_maxin", age=23)  # righttest1(name = "admin_maxin", 23)  # error

2.不定长参数

1. 加了*的参数会以元组（tuple）形式导入,存放所有未命名的变量参数（位置参数）

2. 加了**的参数会以字典的形式导入（关键字参数）

3. **的参数不能出现在*的参数的前边

4. *可以单独出现，*后的参数必须通过关键字调用

def test2_1(name, age=18, *args):print(name, age)print(type(args))print(args)def test2_2(**kwargs):print(type(kwargs))print(kwargs)def test3_3(name, *, age=18):  print(name, age)if "__main__" == __name__:test2_1("mx", 20, 1, 2, 3, 4)test2_2(name="mx", age=23)test3_3("mx", age=23)OUTPUT:
--> mx 20<class 'tuple'>(1, 2, 3, 4, 5)
--> <class 'dict'>{'name': 'mx', 'age': 23}
--> mx 23

3.函数的返回值

1. 返回值数等于0，返回NULL

2. 返回值数等于1，返回object

3. 返回值数>1，返回tuple

def test3_1(name="mx", age=23):    print(name, age)def test3_2(name="mx", age=23):   return namedef test3_3(name="mx", age=23):return name, ageif "__main__" == __name__:print(type(test2_1()))print(type(test2_2()))print(type(test2_3()))OUTPUT:
<class 'NoneType'>
<class 'str'>
<class 'tuple'>

4.变量作用域

python3中变量作用域一共有4种：

1. L(local)局部作用域

2. Enclosing闭包函数外的函数中

3. G(global)全局作用域

4. B(Built - in)内建作用域

变量查找规则：局部找不到便会去局部外的局部查找（例如闭包），再找不到就会去全局找，再者去内建中查找。

x = int(2.9)         # 内建作用域
g_count = 0          # 全局作用域def outer():o_count = 1      # 闭包函数外的函数中x = 3def inner():     # 闭包函数i_count = 2  # 局部作用域print(x)inner()if "__main__" == __name__:outer()OUTPUT:
--> 3

5.匿名函数（lambda）

1. lambda 只是一个表达式，函数体比 def 简单很多

2. lambda主体是一个表达式，而不是代码块。仅能在lambda表达式中封装有限的逻辑进去。

3. lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

4. 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

注意：匿名函数同样支持默认值参数

y = lambda x=2: x**2if "__main__" == __name__:print(y())print(y(3))OUTPUT:
--> 4
--> 9

6.函数递归调用

1. 必须有一个明确的结束条件

2. 每进入更深一层次的递归，问题的规模相比于上一次递归都应该有所减少

3. 递归的效率不高，层次过多会造成栈溢出（函数的调用是通过栈（stack）这种数据类型来完成的，由于栈的大小不是无限的，所以递归调用的次数过多会导致栈溢出。）

注意：python中最大递归深度为999

 

7.函数式编程

函数式编程语言是一种抽象程度非常高的编程范式，纯粹的函数编程语言编写的函数没有变量。因此任何一个函数只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入可能得到不同的输出，因此，这种函数是有副作用的。函数式编程的一个特点就是，允许将函数本身作为参数传入另一个函数，还允许返回一个函数。python对函数式编程提供了部分支持，由于python允许使用变量，因此，python不是纯函数式编程语言。

注意： 完全函数式编程热门语言：lisp, haskell, erlang等

# （1+2）*3-4
var result = subtract(multiply(add(1, 2) + 3) - 4)

8. 高阶函数

 函数接收另外一个函数作为参数，这种函数称之为高阶函数

9.global和nonlocal关键字

当内部作用域想要修改外部作用域的变量时，则会用到这两个关键字。

1. global: 修改全局变量

2. nonlocal: 修改局部外的局部中的变量

num = 1def test9_1():global numprint(num)num = 123print(num)if "__main__" == __name__:test9_1()print("查看全局变量是否发生变化：", num)

def outer():num = 1def inner():nonlocal num   # nonlocal关键字声明num = 123print(num)inner()print("查看局部外的局部当中的变量是否发生变化：", num)if "__main__" == __name__:outer()

10.内置函数

https://blog.csdn.net/admin_maxin/article/details/81806081