python自定义函数def定义,三种传参（位置传参，关键字传参，默认值传参），个数可变的位置参数，个数可变的关键字参数，变量作用域，lambda匿名函数，常见内置函数

python自定义函数

1.定义

直接用 def 来完成定义：

2.位置传参，关键字传参，默认值传参

传参时候可以和别的语言一样放对位置直接传参，也可以放错位置但是用=来打乱顺序传参（关键字传参），
两个想混用时候需要先写位置传参再写关键字传参

默认值传参就是在形参的位置直接等于了一个值，这样后来调用时候可以写也可以不写值，例如fun（）这样空空的直接调用
定义函数时候位置参数和关键字参数同时存在时位置参数放在前边

3.可变参数

①个数可变的位置参数

元组是可迭代的，int是不可迭代的，可以这样思考为何个数可变的位置参数的数据类型是元组而不是不可迭代的类型例如int，在传参时候如果想展开数据，例如list，可以在参数前边加一个*，例如fun(*[10,20,20,30])

def fun(*num):
    print(type(num))
    for i in num:
        print(i)

fun(10,20,20,30)#<class 'tuple'>
fun([10,20,20,30])#<class 'tuple'> [10, 20, 20, 30]
fun(*[10,20,20,30])#<class 'tuple'> 10 20 20 30

②个数可变的关键字参数

数据类型是字典 ，如果想要直接传入一个字典，需要用**解包，否则会出错

def fun(**num):
    print(type(num))
    for key,value in num.items():
        print(key,'---',value)

fun(cat=12,re=14)#<class 'dict'>

4.python中的return

在Python中，一旦自定义函数中的return语句被执行，无论它位于函数的哪个位置，该函数都会立即终止执行，并将控制权返回给调用者。return语句可以返回一个值给调用者，也可以不带任何值（即返回None）。

返回值是多个时候，类型为tuple

def fun(num)
...
return a,b,c

#可以通过系列解包赋值完成赋值

a,b,c=fun(10)

5.变量的作用域

global修饰的局部变脸会变成全局变量，需要注意声明和赋值需要分开

def fun(num)
...
global a
a=10

6.匿名函数

基本语法

lambda arguments: expression

arguments 是传递给函数的参数。参数可以有多个，用逗号隔开。
expression 是关于参数的单个表达式。表达式的结果就是 lambda 函数的返回值。
示例
1.简单的 lambda 函数

# 定义一个lambda函数，接受两个参数并返回它们的和  
add = lambda x, y: x + y  
  
# 使用这个lambda函数  
result = add(5, 3)  
print(result)  # 输出: 8

2.作为参数传递给高阶函数
lambda 函数经常用作高阶函数（接受函数作为参数或返回函数的函数）的参数。例如，使用 filter() 函数筛选列表中的元素，或者 map() 函数对列表中的每个元素应用某个函数。

# 使用lambda函数和filter()筛选偶数  
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))  
print(even_numbers)  # 输出: [2, 4, 6, 8, 10]  
  
# 使用lambda函数和map()将列表中的每个元素加倍  
numbers = [1, 2, 3, 4, 5]  
doubled = list(map(lambda x: x * 2, numbers))  
print(doubled)  # 输出: [2, 4, 6, 8, 10]

3.排序时使用 lambda
lambda 函数还可以用于 sorted() 函数的 key 参数，以便根据自定义的规则对列表进行排序。

# 使用lambda函数对元组的列表按照元组的第二个元素进行排序  
pairs = [(1, 'one'), (3, 'three'), (2, 'two'), (4, 'four')]  
pairs.sort(key=lambda pair: pair[1])  
print(pairs)  # 输出: [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
lambda 函数提供了一种快速定义单行函数的方法，特别适用于需要函数对象但又不想正式命名一个函数的场合。

student=[{'score':98},{'score':100}]
student.sort(key= lambda x:x.get('score'),reverse=True)
print(student)

7.递归

Python中的递归通常指的是通过函数自身来调用自身，以解决或简化问题的一种方法。递归的关键在于定义一个能够逐渐接近问题解的基准情况（base case），以及一个或多个递归步骤，这些步骤会将问题分解成更小、更易于解决的部分。

归公式的一般形式可以表示为：

def recursive_function(n):  
    # 基准情况  
    if n == base_case:  
        return base_result  
    # 递归步骤  
    else:  
        # 使用更小的n值调用自身，并基于该调用的结果进行计算  
        return some_operation(recursive_function(n-1), other_parameters)

8.常见内置函数

需要注意对于filter和map函数中，形参有function，在写的时候需要注意filter（fun，iter），避免在函数位置加（）这样就会变成调用。可以用匿名函数lambda来写这两个函数，参考前边
map（）函数的目的在于讲function在iter中每一个元素的位置都执行一次，可以减少使用for来遍历循环
filter（）函数目的在于筛选满足function条件的iter元素

enumerate 是 Python 中的一个内置函数，它用于将一个可遍历的数据对象（如列表、元组或字符串）组合为一个索引序列，同时列出数据和数据下标，通常用在 for 循环当中。这样，你就可以在循环中同时获取到元素的值和它的索引（或位置）。

基本语法如下：

enumerate(iterable, start=0)

iterable：一个可迭代对象，如列表、元组或字符串。
start：下标起始位置，默认为0。
返回值是一个枚举对象，该对象是一个迭代器，它生成由 (index, value) 组成的元组，其中 index 是从 start 开始计数的索引，value 是从 iterable 中取出的元素。

# 示例：使用 enumerate 遍历列表  
fruits = ['apple', 'banana', 'cherry']  
  
for index, fruit in enumerate(fruits):  
    print(f"Index: {index}, Fruit: {fruit}")  
  
# 输出：  
# Index: 0, Fruit: apple  
# Index: 1, Fruit: banana  
# Index: 2, Fruit: cherry  

format内置的可以这样