【Python语言基础】13、函数-03-优快云博客

文章目录

1. 递归

递归简单的理解就是自己引用自己，递归函数就是在函数中自己调用自己

def fn() : 
	fn()

# 这是一个无穷递归，如果调用fn()程序内存会溢出

递归是一种解决问题的方式，和循环很像。
递归的思想就是：

将一个大问题分解为一个个小的问题，直到问题无法分解，再去解决问题

递归函数的两个条件：

基线条件：问题可以被分解为的最小问题，当满足基线条件时，递归将不再执行
递归条件：将问题继续分解的条件

# 使用递归函数求任意数的阶乘
def fac(n) : 
    '''
        该函数用来求任意数的阶乘
            参数:
                n 需要求阶乘的数字
    '''
    # 基线条件 等于1时不再需要递归
    if n == 1 : 
        return 1
    # 递归条件
    return n * fac(n - 1)

print(fac(10))

# 结果：
3628800

***Repl Closed***

递归和循环类似，基本上可以互相代替

2. 递归练习

练习1：创建一个函数power来为任意数字做幂运算 n ** i

def expon(n,i) : 
    '''
        该函数用来求解 n 的 i 次幂
        参数:
            n 做幂运算的数字
            i 幂运算次数
    '''
    # 基线条件
    if i == 1 : 
        return n

    # 递归条件
    return n * expon(n , i-1)

print(expon(2,3))

# 结果：
8

***Repl Closed***

练习2：创建一个函数，用来检查一个任意的字符串是否是回文字符串（回文字符串是一个对称字符串，例如：上海自来水来自海上）。

def check(txt_s) : 
    '''
        该函数用来检查输入的字符串是否为回文字符串
    '''

    # 基线条件
    if len(txt_s) < 2 : 
        return True
    elif txt_s[0] != txt_s[-1] : 
        return False

    # 递归条件
    return check(txt_s[1:-1])

print('上海自来水来自海上 是否为回文:',check('上海自来水来自海上'))

# 结果：
上海自来水来自海上 是否为回文: True

***Repl Closed***

3. 高阶函数

在Python中，函数是一等对象，具有如下特点：

对象是在运行时创建的
能赋值给变量或者作为数据结构中的元素
能作为参数传递
能作为返回值返回

高阶函数：高阶函数至少需要符合以下特点之一：

接收一个或多个函数作为参数
将函数作为返回值返回

# 判断参数是否为奇数
def fn_Odd(n) : 
    if n % 2 != 0 : 
        return True
    return False

# 判断参数是否为偶数
def fn_Even(n) : 
    if n % 2 == 0 :
        return True
    return False


# 判断参数是否为3的倍数
def fn_ThreeTimes(n) : 
    if n % 3 == 0 : 
        return True
    return False

l = [2,5,7,9,6,21,45,12,35,65]

# 定义的高阶函数
def fn_cal(func,lst) : 
    new_list = []

    for s in lst : 
        if func(s) : 
            new_list.append(s)

    return new_list


# 输出
print(fn_cal(fn_Odd,l))
print(fn_cal(fn_Even,l))

# 结果 :
[5, 7, 9, 21, 45, 35, 65]
[2, 6, 12]

***Repl Closed***

filter()函数
在Python中有个内置函数 filter函数可以实现上面 fn_cal 函数的功能—通过传入一个函数对一个可迭代的对象进行处理。

filter 函数

可以从序列中过滤出符合条件的元素，保存到一个新的序列中
参数1：函数，根据该函数来过滤序列了（可迭代结构）
参数2：需要过滤的序列（可迭代结构）
返回值：过滤后新序列（可迭代结构）

eg：res = filter(fn_Odd,l)

4. 匿名函数

匿名函数(lambda函数表达式)专门用来创建一些简单的函数，是一种语法糖。匿名函数一般作为参数使用，其他地方一般不会使用

语法: lambda 参数列表 : 返回值

def fn(a , b) : 
    return a + b
    
# 使用lambda表达式如下
lambda a,b : a + b

# lambda的调用
res = filter(lambda i : n % 2 != 0,l)

map()函数
map()函数可以对可迭代对象中的所有元素做指定的操作，然后将其添加到一个新的对象中返回


l = [1,2,3,4,5,6,7,8]

# 对l中的元素进行批量增加1
new_l = map(lambda i : i + 1,l)

print(list(new_l))

# 结果
[2, 3, 4, 5, 6, 7, 8, 9]

***Repl Closed***

5.sort方法

sort()方法用来对列表中的元素进行排序。sort方法默认是直接比较列表中的元素的大小，它会直接对原列表进行排序，排序后原列表的顺序会改变，并且该方法没有返回值（返回 None）。

基本用法

# 默认根据字符大小进行比较
s = ['A','BB','CCC','DD','FFFFF','EEEEEE']

s.sort()

print(s)

# 结果
['A', 'BB', 'CCC', 'DD', 'EEEEEE', 'FFFFF']

***Repl Closed***

降序排序
list.sort() 方法可以通过 reverse 参数实现降序排序，reverse=True 表示降序，reverse=False 表示升序（默认值）。

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
my_list.sort(reverse=True)
print(my_list)

# 结果：
[9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1]

***Repl Closed***

自定义排序规则
在sort()可以接受一个关键字参数key，key需要一个函数作为参数，当设置了函数作为参数，每次都会以列表中的一个元素作为参数来调用函数，并且使用函数的 返回值 来比较元素的大小。

可以使用 key 参数指定一个函数，该函数会作用于列表中的每个元素，然后根据函数的返回值进行排序。例如，按字符串长度对字符串列表进行排序

# 根据字符长度进行比较排序
s = ['A','BB','CCC','DD','FFFFF','EEEEEE']

s.sort(key=len)

print(s)

# 结果
['A', 'BB', 'DD', 'CCC', 'FFFFF', 'EEEEEE']

***Repl Closed***

s = ['3',2,'1',4,'5',6]

s.sort(key=int)

print(s)

# 结果：
['1', 2, '3', 4, '5', 6]

***Repl Closed***

6. sorted()函数

这个函数和sort()的用法基本一致，但是sorted()可以对任意的序列进行排序，并且使用sorted()排序不会影响原来的对象，而是返回一个新的对象

基本用法

s = ['3',2,'1',4,'5',6]

print('排序前:',s)
f = sorted(s,key=int)
print('排序后:',s)
print('排序结果:',f)

# 结果
排序前: ['3', 2, '1', 4, '5', 6]
排序后: ['3', 2, '1', 4, '5', 6] # 排序前后原数据没有发生变化
排序结果: ['1', 2, '3', 4, '5', 6]

***Repl Closed***

降序排序
同样可以使用 reverse 参数实现降序排序。

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_list = sorted(my_list, reverse=True)
print(sorted_list)

自定义排序规则
和 list.sort() 方法一样，sorted() 函数也可以使用 key 参数指定排序规则。例如，按字典中某个键的值对字典列表进行排序

students = [
    {"name": "Alice", "age": 20},
    {"name": "Bob", "age": 18},
    {"name": "Charlie", "age": 22}
]
sorted_students = sorted(students, key=lambda x: x["age"])
print(sorted_students)