【三十二】高阶函数、递归函数和面向对象

已于 2023-03-04 11:39:23 修改
阅读量97 收藏
点赞数
分类专栏： 从零入门玩转python 文章标签： python 开发语言
于 2023-03-04 11:33:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46395534/article/details/129332428
版权

常用高阶函数

文章目录

定义：参数或（和）返回值为其他函数的函数

filter(function, iterable)

  • function：函数（function 必需能够接受1个实参），也可以为 None
  • iterable：可迭代对象
  • 将 iterable 中每个元素作为参数传递给函数，根据函数的返回结果进 行判断 True 或 False，将判断为 True 的 iterable 中的元素构建新的迭代器并返回
  • 如果 function 为 None，直接判断 iterable 中元素 True 或 False，再 返回为 True 的元素构建的新的迭代器
# 思考：如果换成 lambda x: print(x-1) 会怎样?
object1 = filter(lambda x: x - 1, [1, 2, 3, False, 4])
print(list(object1))  # [2, 3, False, 4]
object3 = filter(None, [1, 2, 0, 3, False, 4])
print(list(object3))  # [1, 2, 3, 4]

map(func, *iterables)

  • func：函数（func 必需能够接收 iterables 个数的实参）
  • iterables：可迭代对象 用 iterables 中的每个元素作为函数的参数来调用函数，以迭代器形式返回所有结果
  • 当有多个 iterables 对象时，最短的 iterables 耗尽则函数停止
def square(a):
    return a ** 2  # 思考：如果改为 print(a**2) 会怎样?


result = map(square, [1, 2, 3])
print(list(result))  # [1, 4, 9]

result = map(lambda a: a ** 2, [1, 2, 3])
print(list(result))  # [1, 4, 9]

result = list(map(float, ["1", "2", "3"]))
print(result)  # [1.0, 2.0, 3.0]

# 类似于zip的取元素方式
result = list(map(lambda x, y, z: x + y + z, [1, 2, 3], [3, 2, 1], [1, 3, 2]))
print(result)  # [5, 7, 6]

# 当有多个 iterables 对象时，最短的 iterables 耗尽则函数停止
result = list(map(lambda x, y, z: x + y + z, [1, 2, 3], [3,
                                                         2, 1], [1, 3]))
print(result)  # [5, 7]

reduce(function, iterable[, initial])

  • function：函数（function 必需能够接收两个实参）
  • iterable：可迭代对象
  • initial：初始值
  • 在 Python2 中 reduce() 是内置函数，而在Python3中 reduce() 函数是 在functools模块中的，所以在使用的时候需要先导入 functools 模块
  • 在没有指定 initial 参数时，先把 iterable 的前两个元素作为参数调用 函数，把这次函数的结果以及iterable 的下一个元素又作为参数再调用 函数，以此类推
  • 在指定 initial 参数时，先把 initial 值和 iterable 的第一个元素作为参 数调用函数，把这次函数的结果以及 iterable 的下一个元素又作为参 数再调用函数，以此类推
  • 如果 iterable 为空，返回 initial ，此时如果没有指定 initial，则报错
  • 如果 iterable 只有一个元素且没有指定 initial，返回该元素
from functools import reduce


def add(m, n):
    s = m + n
    return s  # 如果改为 print(s) 会怎样?


# 过程：[(1+2)+3]+4 = 10
result = reduce(add, [1, 2, 3, 4])
print(result) # 10

# 过程：2*[2*(2*5+1)+2]+3 = 51
result = reduce(lambda x, y: 2 * x + y, [1, 2, 3], 5)
print(result) # 51

# iterable为空，返回initial
result = reduce(lambda x, y: 10 * x + 2 * y, [], 123)
print(result)  # 123

# iterable只有一个元素且没有指定 initial，返回该元素
result = reduce(lambda x, y: 10 * x + 2 * y, [123])
print(result)  # 123

# 过程：10*2 + 2*123 = 266
result = reduce(lambda x, y: 10 * x + 2 * y, [123], 2)
print(result)

递归函数（了解）

定义：程序调用自身的编程技巧称为递归。

思想：将一个大问题分解成一个个的小问题，然后再从小问题回推出大问题

一般来说，递归函数要满足2个条件：

  • 递归边界条件（一般到递归边界则终止当前递归）
  • 递归推理（一般是提取重复的子问题，不断向递归边界靠拢或者不断 缩小问题规模）

兔子问题

一般而言，兔子在出生两个月后，就有繁殖能力，一对兔子每个月能生出一对 小兔子来。如果所有兔子都不死，那么怎么确定第 n 个月有多少对兔子呢？

# 循环实现
def func(m):
    m0 = 1
    m1 = 1
    for _ in range(m-1):
   		 m0, m1 = m1, m0+m1
    return m1

for i in range(10):
	print(func(i))
    
# 递归实现
def get_rabbits(m):
    if m < 2:
    	return 1
	return get_rabbits(m-1) + get_rabbits(m-2)


print(get_rabbits(12))

最大递归深度限制

def get_rabbits(m):
	if m < 2:
		return 1
	return get_rabbits(m-1) + get_rabbits(m-2)

print(get_rabbits(998))
print(get_rabbits(999))


import sys
def get_rabbits(m):
	if m < 2:
		return 1
	return get_rabbits(m-1) + get_rabbits(m-2)


print(sys.getrecursionlimit()) # 返回默认的最大递归深度1000
sys.setrecursionlimit(1500) # 设置最大递归深度为1500
print(get_rabbits(999)) # 放宽最大递归深度之后不报错了

解决递归重复计算问题

当 m 比较大时，比如 m=50，会发现程序计算会变得非常慢，因为递归程序进 行了大量的重复计算；要解决递归的重复计算问题，只要把之前已经计算过的 数和结果储存起来，后面如果再计算这个数就直接取结果

store={}
def get_rabbits(m):
	if m < 2:
		return 1
    
if m in store:
	return store[m]

result = get_rabbits(m-1) + get_rabbits(m-2)
store[m] = result
return result

for m in range(1000):
    result = get_rabbits(m)
    if m == 999: print(result)

初识面向对象

模拟学生和老师的一天

面向过程（早期语言的编程）

image-20230304104056434

count_s = 0
stu1 = "张三"
age_s = 18
adres_s = "黄土高坡"

print(f"大家好! 我是{stu1}, 今年{age_s}岁, 家住在{adres_s},
欢迎大家有空来玩哦!")
      
count_s += 1
print(f"{stu1}起床")
print(f"{stu1}刷牙")
      
print(f"{stu1}洗脸")
print(f"{stu1}吃菜")
      
print(f"{stu1}扒饭")
print(f"{stu1}账号登录成功")
      
print(f"{stu1}看视频")
print(f"{stu1}写代码")
      
print(f"{stu1}吃菜")
print(f"{stu1}扒饭")
      
print(f"{stu1}看视频")
print(f"{stu1}写代码")
      
print(f"{stu1}吃菜")
print(f"{stu1}扒饭")
      
print(f"{stu1}刷牙")
print(f"{stu1}洗脸")
      
print(f"{stu1}睡觉")
      
print(f"当前统计的学生人数是: {count_s} 人")

count_t = 0
teacher1 = "老王"
age_t = 40
adres_t = "人民广场"

print(f"大家好! 我是{teacher1}, 今年{age_t}岁, 家住在{adres_t}, 欢迎大家有空来玩哦!")

count_t += 1

print(f"{teacher1}起床")

print(f"{teacher1}刷牙")
print(f"{teacher1}洗脸")

print(f"{teacher1}吃菜")
print(f"{teacher1}扒饭")

print(f"{teacher1}今日打卡成功")

print(f"{teacher1}授课")
print(f"{teacher1}答疑")
print(f"{teacher1}写代码")

print(f"{teacher1}吃菜")
print(f"{teacher1}扒饭")

print(f"{teacher1}授课")
print(f"{teacher1}答疑")
print(f"{teacher1}写代码")

print(f"{teacher1}吃菜")
print(f"{teacher1}扒饭")

print(f"{teacher1}刷牙")
print(f"{teacher1}洗脸")

print(f"{teacher1}睡觉")

print(f"当前统计的老师人数是: {count_t} 人")

面向过程（结构化编程）

image-20230304104337393

count_s = 0
stu1 = "张三"
age_s = 18
adres_s = "黄土高坡"

print(f"大家好! 我是{stu1}, 今年{age_s}岁, 家住在{adres_s},欢迎大家有空来玩哦!")

count_s += 1


def wash(name):
    print(f"{name}刷牙")
    print(f"{name}洗脸")
    
    
def eat(name):
    print(f"{name}吃菜")
    print(f"{name}扒饭")
    
    
def study(name):
    print(f"{stu1}看视频")
    print(f"{stu1}写代码")
    print(f"{stu1}起床")
    
    
wash(stu1)

eat(stu1)

print(f"{stu1}账号登录成功")

study(stu1)

eat(stu1)

study(stu1)

eat(stu1)

wash(stu1)

print(f"{stu1}睡觉")

print(f"当前统计的学生人数是: {count_s} 人")

count_t = 0
teacher1 = "老王"
age_t = 40
adres_t = "人民广场"

print(f"大家好! 我是{teacher1}, 今年{age_t}岁, 家住在{adres_t}, 欢迎大家有空来玩哦!")

count_t += 1

def wash(name):
    print(f"{name}刷牙")
    print(f"{name}洗脸")
    
    
def eat(name):
    print(f"{name}吃菜")
    print(f"{name}扒饭")
    
    
def work(name):
    print(f"{name}授课")
    print(f"{name}答疑")
    print(f"{name}写代码")
    print(f"{teacher1}起床")
    
    
wash(teacher1)

eat(teacher1)

print(f"{teacher1}今日打卡成功")

work(teacher1)

eat(teacher1)

work(teacher1)

eat(teacher1)

wash(teacher1)

print(f"{teacher1}睡觉")

print(f"当前统计的老师人数是: {count_t} 人")

面向对象（高内聚低耦合）

image-20230304104601325

程序 = 数据 + 算法。面向过程编程，更侧重于算法；而面向对象编程更侧重于数据。

class Student:
	count = 0
    
    def __init__(self, name, age, address):
        self.name = name
        self.age = age
        self.address = address
        self.show_time()
        Student.count += 1
        
        
	def show_time(self):
        print(f"大家好! 我是{self.name}, 今年{self.age}岁,
        家住在{self.address}, 欢迎大家有空来玩哦!")
              
              
    def get_up(self):
        print(f"{self.name}起床")
              
    def wash(self):
        print(f"{self.name}刷牙")
        print(f"{self.name}洗脸")
              
              
    def eat(self):
        print(f"{self.name}吃菜")
        print(f"{self.name}扒饭")
              
              
    def login_ID(self):
    	print(f"{self.name}账号登录成功")
              
              
    def study(self):
        print(f"{self.name}看视频")
        print(f"{self.name}写代码")

   def login_ID(self):
		print(f"{self.name}账号登录成功")
              
              
	def study(self):
		print(f"{self.name}看视频")
		print(f"{self.name}写代码")
	
     def sleep(self):
		print(f"{self.name}睡觉")

     @classmethod
	def counter(cls):
		print(f"当前统计的学生人数是: {cls.count} 人")


stu1 = Student("张三", 18, "黄土高坡")
stu1.get_up()
stu1.wash()
stu1.eat()
stu1.login_ID()
stu1.study()
stu1.eat()
stu1.study()
stu1.eat()
stu1.wash()
stu1.sleep()
stu1.counter()


class Teacher:
	count = 0
    
    
    def __init__(self, name, age, address):
        self.name = name
        self.age = age
        self.address = address
        self.show_time()
        
Teacher.count += 1

    def show_time(self):
        print(f"大家好! 我是{self.name}, 今年{self.age}岁,家住在{self.address}, 欢迎大家有空来玩哦!")

    def get_up(self):
		print(f"{self.name}起床")

        
    def wash(self):
   	    print(f"{self.name}刷牙")
		print(f"{self.name}洗脸")
        
        
    def eat(self):
        print(f"{self.name}吃菜")
        print(f"{self.name}扒饭")
        
        
	def clock_in(self):
        print(f"{self.name}今日打卡成功")
        
        
    def work(self):
        print(f"{self.name}授课")
        print(f"{self.name}答疑")
        print(f"{self.name}写代码")
        
        
    def sleep(self):
   	    print(f"{self.name}睡觉")
        
        
	@classmethod
	def counter(cls):
		print(f"当前统计的老师人数是: {cls.count} 人")

        
teacher1 = Teacher("老王", 40, "人民广场")
teacher1.get_up()
teacher1.wash()
teacher1.eat()
teacher1.clock_in()
teacher1.work()
teacher1.eat()
teacher1.work()
teacher1.eat()
teacher1.wash()
teacher1.sleep()
teacher1.counter()

class Person:
    def __init__(self, name, age, address):
        self.name = name
        self.age = age
        self.address = address
        self.show_time()
        
        
    def show_time(self):
   	    print(f"大家好! 我是{self.name}, 今年{self.age}岁,家住在{self.address}, 欢迎大家有空来玩哦!")
        
        
    def get_up(self):
    	print(f"{self.name}起床")
        
        
    def wash(self):
        print(f"{self.name}刷牙")
        print(f"{self.name}洗脸")
        
        
    def eat(self):
        print(f"{self.name}吃菜")
        print(f"{self.name}扒饭")
        
        
    def sleep(self):
    	print(f"{self.name}睡觉")


class Student(Person):
	count = 0
    
    
	def __init__(self, name, age, address, classes):
		super().__init__(name, age, address)
		self.classes = classes
        
	Student.count += 1
    
    def login_ID(self):
   		print(f"{self.name}账号登录成功")
        
	def study(self):
        print(f"{self.name}看视频")
        print(f"{self.name}写代码")
    
    @classmethod
	def counter(cls):
		print(f"当前统计的学生人数是: {cls.count} 人")
        
class Teacher(Person):
	count = 0
    
	def __init__(self, name, age, address, department):
		super().__init__(name, age, address)
		self.department = department
        
        
Teacher.count += 1


    def clock_in(self):
    	print(f"{self.name}今日打卡成功")
        
        
    def work(self):
   	    print(f"{self.name}授课")
		print(f"{self.name}答疑")
		print(f"{self.name}写代码")
        
    @classmethod
	def counter(cls):
		print(f"当前统计的老师人数是: {cls.count} 人")

stu1 = Student("张三", 18, "黄土高坡", "高三1班")
Student.counter()
teacher1 = Teacher("老王", 38, "人民广场", "教育部")
teacher2 = Teacher("老翁", 39, "黄浦江", "教育部")
teacher3 = Teacher("老李", 40, "黄浦江", "教导处")
Teacher.counter()

总结：初识面向对象

编程语言的历程：

面向过程(早期编程语言)—> 面向过程(结构化编程) —>面向对象

面向过程(早期编程语言):没有复用性

面向过程(结构化编程)：提高同类代码的复用性，但几乎没有可拓展性

面向对象：提高复用性、可拓展性

名字不好起的名字都有人用？
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python高阶函数心得笔记,python高阶函数知识.doc
10-01
高阶函数的应用场景非常广泛，例如，在数据处理、算法实现、Web 开发等领域都可以使用高阶函数来简化代码和提高效率。 高阶函数是 Python 中的一种强大且灵活的技术，可以帮助我们编写更加简洁、灵活和高效的代码。
08 第八节课笔记(迭代器、匿名函数)
growingtree77的博客
08-04 150
第八节课笔记
高阶函数与递归
weixin_30278311的博客
05-05 72
什么是高阶函数？ 　　变量可以指向函数，函数的参数能接收变量，函数可以接收另一个函数作为参数，我们称为高阶函数。 def calc(x): return x*x f = calc f = lambda x:x*x #匿名函数 变量指向函数 x = 10 def calc(x): return x*x 函数接收变量 def fu...
python的高阶函数和递归函数
代码改变世界
03-29 246
函数名字也是一个变量，他里面存的是代码块若影响到效率了，就用循环。尽量少用。
递归等高阶函数
weixin_43811679的博客
06-08 149
函数的一些高阶用法 1.递归函数：我调我自己 递归函数就是定义了一个函数，然后在函数内，自己调用了自己这个函数； 递归函数内必须要有结束，不然就会一直调用下去，直到调用的层数越来越多，栈溢出； 递归函数：一层一层的进入，再一层一层的返回。 【注意！！一定是有进入有返回！！！】 # 初步认识 递归函数 3 2 1 0 def digui(num): print(num) # 3 2 1 0 # 检测当前的值是否到了零 if num > 0: # 调用函数.
高阶函数、闭包、递归
前端开发-陈善强
12-16 182
1. 高阶函数 *** 高阶函数是对其他函数进行操作的函数，它接收函数作为参数或将函数作为返回值输出 如下： 此时fn 就是一个高阶函数 函数也是一种数据类型，同样可以作为参数，传递给另外一个参数使用。最典型的就是作为回调函数。 同理函数也可以作为返回值传递回来 2. 闭包 *** 2.1 变量的作用域复习 变量根据作用域的不同分为两种：全局变量和局部变量 函数内部可以使用全局...
Python语言基础6：递归、高阶函数、装饰器
12-21
Python语言基础6：递归、高阶函数、闭包、装饰器 学习笔记 递归 简单理解就是自己引用自己 # 创建一个变量保存结果 n = 10 for i in range(1,10): #range(n,m)函数包含n，不包含m n *= i print(n) # 创建一个函数...
Lua中函数与面向对象编程的基础知识整理
09-21
- **closure（闭包）**：闭包在Lua中广泛使用，可以作为高阶函数参数、创建回调函数、实现函数重定义等。Lua中的所有函数本质上都是closure。 - **非全局函数**：大部分Lua库将函数存储在table中，如`MathLib = {...
javascript之典型高阶函数应用介绍二
12-10
前言 在前一篇文章javascript之典型高阶函数中主要实现了几个典型的functional函数。文章最后也提出了疑问，为啥那样的实现与F#之类的函数式语言“不太一样”呢？今天来试试更“函数式”的实现。 另一种实现 同样地...
高阶函数和递归函数
HashFlag的博客
12-06 123
1.高阶函数： （1）函数名可以进行赋值 def f(*args): print(args) # f([1,2,3]) #([1, 2, 3],) f(*[1,2,3]) #(1, 2, 3) 或： def ft(**kwargs): print(kwargs) #ft(info={'name':'eric'}) f...
Nginx七层（应用层）反向代理：UWSGI代理uwsgi_pass篇
最新发布
jclee95的个人博客
07-10 416
Nginx提供了多种应用层反向代理支持，包括proxy_pass、uwsgi_pass、fastcgi_pass和scgi_pass等。其中，proxy_pass指令可以接受一个URL参数，用于实现对HTTP/HTTPS协议的反向代理；uwsgi_pass用于代理到uWSGI应用服务器；fastcgi_pass用于代理到FastCGI服务器；而scgi_pass则用于代理到SCGI（Simple Common Gateway Interface）应用。这些指令使Nginx能够灵活地处理不同类型的后端服务和应
面试题 21：解释 Python 中的 help() 函数和 dir() 函数？
专注于全栈开发领域
07-10 484
在Python中，help()和dir()是两个非常有用的内置函数，它们可以帮助开发者更好地了解Python对象和模块。
pandas，dataframe使用笔记
分享计算机视觉，C++，嵌入式等知识。
07-05 487
dataframe属于pandas。
Python28-7.3 降维算法之多维缩放MDS
Argulo的博客
07-05 664
多维尺度分析（Multidimensional Scaling, MDS）是一种用于降维的统计技术，其目标是将高维数据嵌入到低维空间中，同时尽量保持原始数据中点与点之间的距离关系。MDS 的目标是将高维数据中的点嵌入到低维（通常是二维或三维）空间中，使得在低维空间中点之间的距离尽量接近原始高维空间中点之间的距离。这通过最小化一个损失函数（通常是应力函数）来实现，应力函数衡量的是原始距离和降维后距离之间的不一致性。：对原始数据中的距离或相似度进行非度量变换，以保留原始数据中的顺序信息，而不是精确的距离值。
一键安装ros及出现问题的解决方案
m0_58173801的博客
07-10 380
catkin_make时出现报错如下。
MySQL空间索引
你的指尖有改变世界的力量
07-10 150
空间类型是建立在空间类型字段上的。
java占位符替换五种方式
weixin_61478518的博客
07-08 281
在业务开发中，经常需要输出文本串。其中，部分场景下大部分文本内容是一样的，只有少部分点是不一样。简单做法是直接拼接字段，但是这会有个问题。后面如果想要修改内容，那么每个地方都要修改，这不符合设计模式中的开闭原则，面向应该对扩展开放，对修改关闭。如何解决这个问题？先来看现实生活中的例子，个人信息填写。一般会要填写表格，已经定义好了姓名，性别，年龄等字段，只要填写对应的个人信息就好了。在程序开发中，我们会预先定义好一个字符串模板，需要改动的点使用占位符。
【Python进阶】函数的扩展
weixin_52854743的博客
07-06 964
python函数的补充，包括函数的嵌套调用、函数的变量作用域、多种参数、拆包和交换变量值、引用和匿名函数

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值