python 函数 变量作用域 函数返回值 函数参数 拆包和交换变量值 引用 可变和不可变类型 递归 lambda 高阶函数

目录

定义函数

调用函数

函数的说明文档

变量作用域

函数的返回值

函数参数

拆包和交换变量值

引用

可变和不可变类型

递归

lambda(匿名函数)

高阶函数

---

定义函数

语法

def 函数名(参数)：

        代码1

        代码2

        ······

调用函数

语法

函数名(参数)

注：①参数可有可无

        ②在python中，函数必须先定义后使用

return作用：①负责函数返回值

                    ②退出当前函数：导致return下方的所有代码（函数体内部）不执行

函数的说明文档

语法：

def 函数名(参数)：

        """说明文档位置"""

        代码

        ······

查看函数说明文档

help(函数名)

变量作用域

• 局部变量：定义在函数体内部的变量，即只在函数体内部生效
  
  作用：在函数体内部，临时保存数据，当函数调用完之后，则销毁局部变量
• 全局变量：在函数体内和体外都能生效的变量
  
  在函数体内修改全局变量：先用关键字global声明a为全局变量，然后再给变量重赋值

函数的返回值

一个函数返回多个返回值各种写法

# 返回元组
# return 1,2
# return(1,2)
# 返回列表
# return [100 , 200]
#返回字典
# return {'name':'python',"age":20}

总结：return后面可以连接列表、元组或字典，以返回多个值

函数参数

1. 位置参数：调用函数时根据函数定义的参数位置来传递参数（传递和定义参数的顺序及个数必须一致）
2. 关键字参数：通过“键=值”形式加以指定（函数调用时，如果有位置参数，位置参数必须再管子参数前面，但关键字参数之间不存在先后顺序）
   
   写法：key = value
3. 缺省参数：也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参
   数的值（所有的位置参数必须出现再默认参数前，包括函数调用和定义；函数调用时，如果为缺省参数传值则修改默认参数；否则使用默认参数）
   
   写法：key = value
4. 不定长参数：也叫可变参数。用于不确定调用的时候会传递多少个参数（不传参数也可以）的场景。此时，可以用包裹（packing）位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便
   
   ①包裹位置传递:传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组（tuple），args是元组类型，这就是包裹位置传递

   #不定长位置参数
   def user_info(*args):

   ②包裹关键字传递：收集所有关键字参数，返回一个字典

   #不定长关键字参数
   def user_info(**kwargs):

   总结：无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程

拆包和交换变量值

拆包

①拆包：元组

def return_num():
    return 100, 200

num1, num2 = return_num()

②拆包：字典

dict1 = {'name':'tom','age':12}
a, b =dict1
print(a)
print(b)
print(dict1[a])
print(dict1[b]
输出：
name
age
tom
12

交换变量值

方法：

a, b = b, a

引用

python中，值是靠引用来传递

我们可以用id()来判断两个变量是否为同一个值的引用。我们可以将id值理解为那块内存的地址标识

可变和不可变类型

• 可变类型
  
  列表
  字典
  集合
• 不可变类型
  
  整形
  浮点型
  字符串
  元组

递归

特点：①函数内部自己调用自己

           ②必须有出口

lambda(匿名函数)

作用：如果一个函数有一个返回值，并且只有一句代码，可以使用lambda简化

语法：

lambda 参数列表：表达式(该表达式必须有返回值)

注：①lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用。

       ②lambda表达式能接收任何数量的参数但只能返回一个表达式的值。

       ③直接打印lambda表达式，输出的是此lambda的内存地址。

lambda的参数形式

①无参数形式：

fn1 = lambda: 100

②一个参数

fn2 = lambda a: a
print(fn2('hello word'))#hello word

③默认参数

fn3 = lambda a, b, c = 10 : a + b + c
print(fn3(1, 2))#13
print(fn3(1, 2, 3))#6

④可变参数：*args(返回一个元组)

fn4 = lambda *args: args
print(fn4(1,2,3))#(1, 2, 3)

⑤可变参数：**kwargs（返回一个字典）

fn5 = lambda **kwargs: kwargs
print(fn5(name = 'python', age = 20))#{'name': 'python', 'age': 20}

lambda运用于字典排序：

students = [
    {'name': 'TOM', 'age': 20},
    {'name': 'ROSE', 'age': 19},
    {'name': 'JACK', 'age': 22}
]
#按name值升序排列
students.sort(key=lambda x : x['name'])
print(students) 
#[{'name': 'JACK', 'age': 22}, {'name': 'ROSE', 'age': 19}, {'name': 'TOM', 'age': 20}]
#按name值降序排列
students.sort(key=lambda x: x['name'],reverse=True)
print(students)
#[{'name': 'TOM', 'age': 20}, {'name': 'ROSE', 'age': 19}, {'name': 'JACK', 'age': 22}]
#按age值升序排列
students.sort(key=lambda x:x['age'])
print(students)
#[{'name': 'ROSE', 'age': 19}, {'name': 'TOM', 'age': 20}, {'name': 'JACK', 'age': 22}]

高阶函数

把函数作为参数传入，这样的函数称为高阶函数，高阶函数是函数式编程的体现。

函数式编程就是指这种高度抽象的编程范式。

abs()：完成对数字求绝对值计算

round()：完成对数字的四舍五入

实例1：将函数作为参数传入到一个函数中

def sum(a,b,f):
    return f(a) + f(b)

print(sum(-1,3,abs))    #4
print(sum(1.2,1.6,round))   #3

内置高级函数

map(func, lst)：将传入的函数变量func作用到lst变量的每个元素中，并将结果组成新的列表(python2)/迭代器(python3)返回

list1 = [1, 2, 3, 4, 5]
def func(x):
    return x**2

result = map(func, list1)   
print(list(result))     #[1, 4, 9, 16, 25]

reduce(func, lst)：其中func必须有两个参数。每次func计算的结果继续和序列的下一个元素做累积计算。（累积：这里指代累加） 

import functools
list1 = [1, 2, 3, 4, 5]

def func(a, b):
    return a + b
result = functools.reduce(func,list1)
print(result)       #15

filter(func, lst)：函数用于过滤序列，过滤掉不符合条件的元素，返回一个filter对象。如果要转换为列表，可以使用list()来转换。

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def func(x):
    return x % 2== 0
result = filter(func, list1)
print(list(result))    #[2, 4, 6, 8, 10]