python基础（十）-----函数（下）

最新推荐文章于 2023-05-05 15:06:20 发布

零度℃192

最新推荐文章于 2023-05-05 15:06:20 发布

阅读量545

点赞数 1

分类专栏： python 基础文章标签： python 开发语言

本文链接：https://blog.csdn.net/qq_70761095/article/details/125989634

版权

python 基础专栏收录该内容

18 篇文章 3 订阅

订阅专栏

1.1 高级用法

1.函数可以被引用(可以赋值)

def fn():
    print('我是fn')

f = fn # 赋值函数
f()

2.函数可以作为参数传入另外一个函数

def fn():
    print('我是fn')

def fn2(x): # x = fn
    x() # fn()

fn2(fn)

3.可以将函数作为返回值

def fn():
    print('我是fn')


def fn2(x):  # x = fn
    return x
a = fn2(fn)
print(a)

4.函数可以作为容器的元素

list1 = [1, 2, 3, fn]
list1[3]() # fn()

2.1 匿名函数（lambda）

匿名函数：没有名字的函数

匿名函数用关键字lambda实现

lambda函数的语法,如下

lambda 参数列表:运算表达式

def fn(x):
    return x * x

f = lambda x: x * x
print(f(5))

总结
1.lambda并不会带来程序运行效率的提高，只会使代码更简洁
2.如果使用lambda，lambda内不要循环，有的话用标准函数完成
3.lambda只是为了减少单行函数的定义而存在

3.1 高阶函数

3.1.1 高阶函数简介

abs():对数字求绝对值计算
绝对值：就是将一个数变正数，0还是0


round():四舍五入 bug =》   奇数满足四舍五入，偶数 四舍大于5入
小数二进制。



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

print(ab_sum(-1, -4.5, lambda x:-x))
print(ab_sum(-1, -4.5, abs))
print(ab_sum(-1, -4.5, round))


python所提供的的内置高阶函数
map filter reduce sorted

3.1.2 map（）

语法

map(func,seq):将传入的函数变量func作用到序列变量seq的每个元素中，并将结果组成新的迭代器返回

高阶内置函数 func的参数都是有固定含义

# 将列表中的各个数字+1
list1 = [-1, 2, -3, 4, -5]
# map 可以直接操作序列中的每个元素

print(list(map(lambda x:x+1, list1))) # 222

总结：
	1.map内置函数的作用是操作序列中的所有元素，并返回一个迭代器，迭代器要转列表
    2.lambda表达式可以专门配合高阶内置函数来简洁实现

3.1.3 reduce（）

语法

reduce(func,seq) ：聚合
func 必须要有2个参数

注意：reduce() 传入的参数func必须有2个参数

reduce是将每次函数的结果继续和序列的下一个元素做累计计算(类似于累加法)

func(x,y)

reduce是需要导包，不是内置函数

from functools import reduce // 导入一个功能

def func(x, y):
    return x + y

a = reduce(func, list1)
print(a)
a = reduce(lambda x,y:x+y, list1)
print(a)

总结：

1.reduce就是平时遇见累积的都可以用

2.reduce返回一个值

3.reduce需要导入才能使用 from functools import reduce

3.1.4 filter

语法

filter(func,seq) : 用于过滤序列，过滤掉不符合条件的元素。结果要通过list转换---------(过滤)
    
def func(x): # x就代表每个元素，和map一样
    return 布尔值 # 如果布尔值为真，则保留，否则过滤
# 保留一个序列中所有的偶数

# 除了0和 空字符串 都为
# 常见的转换为False :  0,"",[],(),{},set(),None
# def o2x(x): # 最终版
#     return x % 2 == 0


print(list(filter(lambda x:x%2==0, list1)))

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]


def scy(x):
    if x % 2 == 0:
        return x


print(list(filter(scy,list1)))

3.1.5 sorted

返回一共排序后的序列。

sorted 默认的排序规则函数，参数key ： key就是函数

list2 = ["小明:69", "大明:79", "小美:59", "小芳:89", '小娟:100', "马可波罗:99"]


def f(x):  # x 代表每个值，和map，filter是一样的
    # return ： 返回排序要比较的值
    arr = x.split(":")  # ["木槿",'69']
    # arr[0] 名字
    # arr[1] 分数    字符串
    return int(arr[1])


print(sorted(list2, key=f))  # 编码
print(sorted(list2,key=f,reverse=True))
print(sorted(list2,key=lambda x: int(x.split(":")[1]),reverse=True))

list2 = ["小明:69", "大明:79", "小美:59", "小芳:89", '小娟:100', "马可波罗:99"]


def scy1(x):
 yyds = x.split(":")
 return int(yyds[1])


print(sorted(list2,key=scy1))

4.1 递归函数

递归：函数的内部调用了自己这个就叫递归

def func():
    print('你好，我是天天')
    func() # 函数的代码执行完就结束


func()
# 函数的作用域生命周期：调用时产生，调用结束时销毁

递归的原则

1.如果要定义递归函数，不想让它报错的话，必须要有出口

2.设计一个出口，不断的向出口接近

> 接近出口（参数变化）一般是写在递归调

# 1*2*3*4*......*9
# 阶乘
def f(n):  # n 是 1*2*3* .。。。9 # 1*......100
    if n == 1:
        return 1  # 返回1
    return n * f(n - 1)  # 变化都在递归调用里面写 jc(8)  jc(7) jc(6) jc(5) .... jc(2) jc(1)


print(f(10))  # f(10)  <=> 10*9 * 8*7*6*5*4*3*2*1

5.1 练习

# 1 . 对于序列 [-1,3,-5,-4] 的每个元素求绝对值

# 2 . 用map来处理字符串列表啊,把列表中所有人都变成sb,比方lucy_sb
name=['lucy','lilei','hanmeimei']

# 3 . 将一串数字‘1 3 5 7 8’转化为整型，并以列表形式输出

# 4.  用【递归】实现阶乘，定义一共函数有一个参数n
# 	  返回值是 1*2*3*....*n


# 5 . 
要求用递归实现
斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家列昂纳多·斐波那契（Leonardoda Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……（从第3位开始，每一位数字都是前两位数字之和）
在现代物理、准晶体结构、化学等领域，斐波纳契数列都有直接的应用。
要求输入N，输出第N位数字。如：
输入：8
输出：21

6.1 答案解析

# 1 . 对于序列 [-1,3,-5,-4] 的每个元素求绝对值
list1=[-1,3,-5,-4]
print(list(map(abs,list1)))
# 2 . 用map来处理字符串列表啊,把列表中所有人都变成sb,比方lucy_sb
'第一种方法'
name=['lucy','lilei','hanmeimei']
def scy1(x):
    c=x+'_sb'
    return c
print(list(map(scy1,name)))
'第二种方法'
def scy2(y):
    return y+'_sb'
print(list(map(scy2,name)))
'第三种方法'
print(list(map(lambda x:x+'_sb',name)))
# 3 . 将一串数字‘1 3 5 7 8’转化为整型，并以列表形式输出
l1='1 3 5 7 8'
'第一种方法'
def scy3(m):
    return int(m)
print(list(map(scy3,l1.split(' '))))
'第二种方法'
print(list(map(lambda g:int(g),l1.split(' '))))
# 4.  用【递归】实现阶乘，定义一共函数有一个参数n
# 	  返回值是 1*2*3*....*n
def scy1(n):
    if n==1:
        return 1
    else:
        return n*scy1(n-1)

numbers=int(input("请输入一个正整数: "))
res=scy1(numbers)
print("%d的阶乘是： %d"%(numbers,res))

# 5
# 要求用递归实现
# 斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家列昂纳多·斐波那契（Leonardoda Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，
# 指的是这样一个数列：1、1、2、3、5、8、13、21、34、……
# （从第3位开始，每一位数字都是前两位数字之和）
# 在现代物理、准晶体结构、化学等领域，斐波纳契数列都有直接的应用。
# 要求输入N，输出第N位数字。如：
# 输入：8
# 输出：21
def yyds(n):
    if n == 1 or n == 2:
        return 1
    else:
        return yyds(n - 1) + yyds(n - 2)


n = int(input("请输入数列的项数为： "))
print(yyds(n))