python高级之面向对象编程

一、面向过程与面向对象

面向过程和面向对象都是一种编程方式,只不过再设计上有区别。

1、面向过程pop:

举例:孩子上学

1. 妈妈起床

2. 妈妈洗漱

3. 妈妈做饭

4. 妈妈把孩子叫起来

5. 孩子起床

6. 孩子洗漱

7. 孩子吃饭

8. 妈妈给孩子送学校去

最为典型就是我们的C语言编程。

1》导入各种外部库

2》设计各种全局变量

3》写一个函数

4》写一个函数

5》........

6》写一个main主函数作为程序入口部分

 例:从一个列表中删除并返回最后一个元素和删除元素之后的列表

def pop_element(lst):
    if len(lst) > 0:
        return lst.pop()
    else:
        return "列表为空,无法弹出元素"

# 示例列表
my_list = [1, 2, 3, 4, 5]

# 执行pop操作
result = pop_element(my_list)
print(f"弹出的元素是: {result}")
print(f"当前列表是: {my_list}")
输出结果

- 面向过程的编程思想将一个功能分解为一个一个小的步骤, 我们通过完成一个一个的小的步骤来完成一个程序

- 这种编程方式,符合我们人类的思维,编写起来相对比较简单

- 但是这种方式编写代码的往往只适用于一个功能, 如果要在实现别的功能,即使功能相差极小,也往往要重新编写代码, 所以它可复用性比较低,并且难于维护

优点:简单直观、性能高效、代码简洁。

缺点:不易维护、不易扩展、代码重用性低。

2、面向对象oop:

举例:孩子上学

“妈妈”送“孩子”上学

python、java、C++都是面向对象的编程方式。

 以python为例:从一个列表中删除并返回最后一个元素和删除元素之后的列表

class MyList:
    def __init__(self):
        self.items = []  
    # 1》初始化空列表

    # 2》添加元素
    def append(self, item):
        self.items.append(item)

    # 3》移除并返回最后一个元素(pop操作)
    def pop(self):
        if len(self.items) > 0:
            return self.items.pop()
        else:
            return "列表为空,无法弹出元素"

    # 3》获取当前列表的内容
    def get_items(self):
        return self.items

# 4》创建MyList对象
my_list_obj = MyList()

# 5》向列表添加元素
my_list_obj.append(1)
my_list_obj.append(2)
my_list_obj.append(3)

# 6》执行pop操作
result = my_list_obj.pop()
print(f"弹出的元素是: {result}")
print(f"当前列表是: {my_list_obj.get_items()}")
输出结果

- 面向对象的编程思想,将所有的功能统一保存到对应的对象中 比如,妈妈功能保存到妈妈的对象中,孩子的功能保存到孩子对象中 。要使用某个功能,直接找到对应的对象即可

- 这种方式编写的代码,比较容易阅读,并且比较易于维护,容易复用。

- 但是这种方式编写,不太符合常规的思维,编写起来稍微麻烦一点

优点:模块化、安全性高、代码重用性高。

缺点:学习难度大、性能开销大、调试困难。

二、类和对象

目前我们所学的python中的内置类型都是对象——内置对象,内置对象有时候不能满足我们的需求,需要自定义一些对象。

10, 20, 30, -40, a=10, b=20等等等,都是整数,对其进行抽象——int类。

python 中一切都是对象。

类也是一个对象。

麻雀、鸽子、乌鸦和鹦鹉都属于鸟类

1、类的定义与实例化对象

在python中使用class关键字创建一个类。

语法格式a:

class ClassA:
    # 公共的属性
    def __init__(self):
        pass
    def fun1(self):
        pass
    def fun2(self):
        pass

语法格式b:

class ClassA(object):
    # 公共的属性
    def __init__(self):
        pass
    def fun1(self):
        pass
    def fun2(self):
        pass

 实例化对象的语法:

1》无参

        对象名 = 类名()

2》有参

         对象名 = 类名(参数列表)

例: 输出汽车品牌型号和问世年份

# 定义一个简单的类
class Car(object):
    brand = "比亚迪"  # 实例属性
    model = "秦L DM"
    year = "2024"
    def __init__(self):
        pass
    def display_info(self):  # 实例方法
        pass

# 实例化对象
s1 = Car()
s2 = Car()
s3 = Car()
print(s1.brand)
print(s2.model)
print(s3.year)# 输出:品牌: 比亚迪, 型号: 秦L DM, 年份: 2024

第一个 __init__()方法是一种特殊的方法,被称为类的构造函数或初始化方法,当创建了这个类的实例时就会自动调用该方法。不是必须要定义的,可以在需要的时候再定义。

第二个 self是一个参数,表示对象自身【对象的id号】,里面存放着对象自身的地址。如果希望类中的方法可以被对象调用,第一个参数必须是self。作用是将实例对象与类的方法进行绑定,这样实例的每个对象都能调用“属于”自己的方法。传参时可以省略

class Cat(object):
    def speak(self):
        print(f"{self}在喵喵喵")

d1 = Cat()
d2 = Cat()
d1.speak()
d2.speak()
输出结果

2、访问属性/方法

使用符号 . 进行访问

访问属性:

对象名.属性

访问方法:

对象名.方法名()

3、对象与类的关系

  1. 对象拥有类的所有属性和方法
  2. 对象的属性和方法可以单独添加、删除、修改
  3. 对象与对象之间的属性和方法不可共享
  4. 对象不能独自创建,必须依托于类,类可以实例化N个对象
class Stu:
    def __init__(self, name, ability):
        self.name = name
        self.ability = ability

    def bark(self):
        print(f"{self.name}在打游戏!")

# Stu 是类,stu1 和 stu2 是对象
stu1 = Stu("马斯轩", "会吃饭")
stu2 = Stu("唐朗明", "会学习")

stu1.bark()  # 输出:马斯轩在打游戏!
stu2.bark()  # 输出:马斯轩在打游戏!

还可以使用以下函数的方式来访问属性:

  • getattr(obj, name[, default]) : 访问对象的属性。
  • hasattr(obj,name) : 检查是否存在一个属性。
  • setattr(obj,name,value) : 设置一个属性。如果属性不存在,会创建一个新属性。
  • delattr(obj, name) : 删除属性。

4、魔方方法——构造函数 与 析构函数

  1. __init__ 构造函数:完成对象的初始化工作,方便统一管理、调用类创建对象时,自动执行。
  2. __del__ 析构函数:删除对象时执行一些操作,自动执行。
  3. __str__ 打印方法:输出执行信息,自动执行。
class Car:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return f"轿车{self.name}是黑色的。"

    def __del__(self):
        print(f"轿车{self.name}报废了,去车管所吧!")

# 创建并销毁对象
car = Car("奥迪")
print(car) #轿车奥迪是黑色的。
del car  # 输出:轿车奥迪报废了,去车管所吧!

5、类属性/方法 与 实例对象属性/方法 与 静态方法

类是思维脑图

示例:类属性和方法、实例属性和方法、静态方法

class Vehicle:
    wheels = 4  # 类属性

    def __init__(self, brand):
        self.brand = brand  # 实例属性

    def drive(self):  # 实例方法
        print(f"正在开着{self.brand}的车")

    @classmethod
    def wheels_info(cls):  # 类方法
        print(f"一辆车拥有{cls.wheels}个轮胎。")

    @staticmethod
    def general_info():  # 静态方法
        print("买车是为了开的。")

# 创建实例对象
car = Vehicle("比亚迪")

# 访问实例属性和方法
print(car.brand)  # 输出:比亚迪
car.drive()  # 输出:正在开着比亚迪的车

# 访问类属性和类方法
print(Vehicle.wheels)  # 输出:4
Vehicle.wheels_info()  # 输出:一辆车拥有4个轮胎。

# 调用静态方法
Vehicle.general_info()  # 输出:买车是为了开的。

6、Python的内置类属性

  • __dict__ : 类的属性(包含一个字典,由类的数据属性组成)
  • __doc__ :类的文档字符串
  • __name__: 类名
  • __module__: 类定义所在的模块(类的全名是'__main__.className',如果类位于一个导入模块mymod中,那么className.__module__ 等于 mymod)
  • __bases__ : 类的所有父类构成元素(包含了一个由所有父类组成的元组)
class Student(object):
    """
    定义一个学生类
    属性:名字 年龄
    方法:method_1 method_2
    """
    name = '张三'
    age = 18

    def method_1(self):
        pass

    def method_2(self):
        pass

print(Student.__dict__) #输出:{'__module__': '__main__', '__doc__': '\n    定义一个学生类\n    属性:名字 年龄\n    方法:method_1 method_2\n    ', 'name': '张三', 'age': 18, 'method_1': <function Student.method_1 at 0x00000189521B8AE0>, 'method_2': <function Student.method_2 at 0x00000189521B8C20>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>}
print(Student.__doc__) #输出:
# 定义一个学生类
# 属性:名字 年龄
# 方法:method_1 method_2
print(Student.__name__) #输出:Student
print(Student.__module__) #输出:__main__
print(int.__module__) #输出:builtins
print(Student.__bases__) #输出:(<class 'object'>,)

三、类的封装【私有属性与方法】

封装是类的三大特性之一。

封装指的是隐藏对象中一些不希望让外部所访问的属性或方法。

python中封装其实是通过设置访问权限来体现的,私有属性和私有方法是控制访问权限的组成部分。

1、私有属性

在类的内部使用,不希望外部直接访问的变量。

在python中,使用双下划线作为前缀来定义私有属性。

私有属性在类外不能访问

class Person:
    def __init__(self, name, age):
        self.__name = name  # 私有属性
        self.__age = age    # 私有属性

    def display_info(self):
        print(f"Name: {self.__name}, Age: {self.__age}")

    def set_name(self, name):  # 通过公共方法设置私有属性
        self.__name = name

    def get_name(self):  # 通过公共方法访问私有属性
        return self.__name

# 创建对象
person = Person("小花", 30)

# 访问私有属性会报错
# print(person.__name)  # AttributeError: 'Person' object has no attribute '__name'

# 通过公共方法访问和修改私有属性
print(person.get_name())  # 输出:小花
person.set_name("小明")
print(person.get_name())  # 输出:小明

2、私有方法

和私有属性是一样的。

class Car:
    def __init__(self, brand):
        self.__brand = brand

    def __start_engine(self):  # 私有方法
        print(f"{self.__brand}启动了!")

    def drive(self):
        self.__start_engine()  # 通过公有方法调用私有方法
        print(f"正在驾驶着{self.__brand}的车!")

# 创建对象
car = Car("比亚迪")

# 访问私有方法会报错
# car.__start_engine()  # AttributeError: 'Car' object has no attribute '__start_engine'

# 通过公共方法间接调用私有方法
car.drive()
# 输出:
# 比亚迪启动了!
# 正在驾驶着比亚迪的车!

3、属性装饰器

属性装饰器是实现把方法转为属性的装饰器。

作用:

  1. 把方法转为属性,便于操作属性
  2. 实现对属性的更改(验证)、查看、删除

语法格式:

class 类名(object):
    def __init__(self):
        self.__名字 = xxx
    
    @property
    def 函数名(self):
        return self.__名字
    
    @函数名.setter
    def 函数名(self, m):
        self.__名字 += m
class Car(object):
    def __init__(self, name, color):
        self.name = name
        self.color = color
        self.__num = 20

    @property
    def num(self):
        return self.__num

    @num.setter
    def num(self, x):
        self.__num += x

c1 = Car('法拉利', '红色')
print(c1.name, c1.color, c1.num)
c1.num = 80
print(c1.num)
class Student(object):
    def __init__(self, name):
        self.__name = name

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, new_name):
        if not isinstance(new_name, str):
            print('名字必须是一个字符串')
        else:
            self.__name = new_name

    @name.deleter
    def name(self):
        print("已删除名字")
        del self.__name

s1 = Student('张三')
print(s1.name)
s1.name = 111
s1.name = '华清远见'
print(s1.name)
del s1.name

四、类的继承

面向对象的编程带来的主要好处之一就是代码的重用,实现这种重用的方法之一就是通过继承机制。

通过继承创建的新类称之为【子类】或者【派生类】,被继承的类称之为【父类】、【基类】、【超类】。

1、继承语法格式

class  子类名(父类名列表):
    pass

 举例说明

class Parent(object):
    """
    定义父类
    """
    par_attr = 100

    def __init__(self):
        print("初始化父类")

    def par_fun1(self):
        print("父类方法1")

    def par_fun2(self):
        print("父类方法2")

class Child(Parent):
    """
    定义子类
    """
    child_attr = 666
    def __init__(self):
        print("初始化子类")

    def child_fun1(self):
        print("子类方法1")

c1 = Child()
print(c1.child_attr)
c1.child_fun1()

print(c1.par_attr)
c1.par_fun1()
c1.par_fun2()

2、多继承语法

如果在继承的元组()里面有一个以上的类,就称之为多继承。

class A:
    pass

class B:
    pass

class C:
    pass

class D(A, B, C):
    pass

d1 = D()
print(D.mro())
# python中提供了一个函数mro()用于查看继承的顺序。

3、继承重写父类方法

如果你的父类方法不能满足你得要求,你可以在之类中重写父类的方法。

class Parent(object):
    def method(self):
        print(f"{self}的方法")

class Child(Parent):
    pass

c = Child()
c.method()


# 重写
class Parent(object):
    def method(self):
        print(f"{self}的方法")

class Child(Parent):
    def method(self):
        print("xxxxxxxxxx")
        print(f"{self}的方法")

c = Child()
c.method()

这里列出了一些通用的功能,可以在自己的类重写:

  1. __init__ ( self [,args...] ) 构造函数 简单的调用方法: obj = className(args)
  2. __del__( self ) 析构方法, 删除一个对象 简单的调用方法 : del obj
  3. __repr__( self ) 转化为供解释器读取的形式 简单的调用方法 : repr(obj)
  4. __str__( self ) 用于将值转化为适于人阅读的形式 简单的调用方法 : str(obj)
  5. __cmp__ ( self, x ) 对象比较 简单的调用方法 : cmp(obj, x)

4、python继承特点

  • 在子类中如果需要父类的构造方法,需要显式调用父类的构造方法,或者不重写父类的构造方法。__init__()
  • 在子类中调用父类的方法,需要显式调用,且第一个参数self不能省略。
class Parent(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def method(self):
        print(f"{self}的方法")

class Child(Parent):
    def fun1(self):
        print(self.x , self.y)
# 不重写父类构造方法
c = Child(1, 2)
c.fun1()
class Parent(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def method(self):
        print(f"{self}的方法")

class Child(Parent):
    def __init__(self, x, y, z):
        Parent.__init__(self, x, y)
        self.z = z

    def fun1(self):
        print(self.x , self.y, self.z)

# 重写父类构造方法、里面显式调用父类构造方法
c = Child(1, 2, 33)
c.fun1()
class Parent(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Child(Parent):
    def __init__(self, x, y, z):
        super().__init__(x, y)
        self.z = z

    def add(self):
        return self.x + self.y + self.z

c = Child(1, 1, 1)
print(c.add())
class Parent(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def add(self):
        return self.x + self.y

class Child(Parent):
    def __init__(self, x, y, z):
        super().__init__(x, y)
        self.z = z

    def add(self):
        return super().add() + self.z

c = Child(1, 1, 1)
print(c.add())

5、运算符重载

在Python中,并没有像其他语言(如C++)中那样的内置机制来重载运算符。但是,你可以通过定义特定的方法来模拟运算符重载的行为。

以下是一些常见运算符以及它们对应的特殊方法:

加法:+ 对应 __add__

减法:- 对应 __sub__

乘法:* 对应 __mul__

除法:/ 对应 __truediv__

取模:% 对应 __mod__

幂运算:** 对应 __pow__

位运算:

位运算:>> 对应 __rshift__

位运算:& 对应 __and__

位运算:| 对应 __or__

位运算:^ 对应 __xor__

class Operator(object):
    def __init__(self, x):
        self.x = x

    def __add__(self, other):
        return self.x + other.x * 3

o1 = Operator(1)
o2 = Operator(3)
print(o1 + o2)
class Operator(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return self.x * other.x + self.y * other.y

o1 = Operator(1, 2)
o2 = Operator(3, 4)
print(o1 + o2)

五、类的多态

python中的多态也可以通过方法重写进行。

同一个方法,不同对象显式的结果不同。

class Animal(object):
    name = '动物'
    age = 0
    def speak(self):
        print("动物的声音")

class Dog(Animal):
    def speak(self):
        print("汪汪汪")

class Cat(Animal):
    def speak(self):
        print("喵喵喵")

a = Animal()
d = Dog()
c = Cat()

a.speak()
d.speak()
c.speak()

六、关于下划线说明

  1. __foo__: 以双下划线开头双下划线结尾,定义的是特殊方法,一般是系统定义名字 ,类似 __init__() 之类的,自动。
  2. _foo: 以单下划线开头的表示的是 protected 类型的变量,即保护类型只能允许其本身与子类进行访问,不能用于 from module import ···
  3. __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/915322.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

❤React-React 组件基础(类组件)

❤React-React 组件基础 1、组件化开发介绍 组件化开发思想&#xff1a;分而治之 React的组件按照不同的方式可以分成类组件&#xff1a; 划分方式一&#xff08;按照组件的定义方式&#xff09; 函数组件(Functional Component )和类组件(Class Component)&#xff1b; …

在Java中使用ModelMapper简化Shapefile属性转JavaBean实战

目录 前言 一、原始的处理办法 1、使用Set方法来转换 2、使用构造方法转换 二、基于ModelMapper的动态转换 1、ModelMapper简介 2、集成到项目中 3、Shapefile属性读取 三、总结 前言 在现代软件开发中&#xff0c;尤其是在多层架构中&#xff0c;经常需要将数据从一个…

Arduino IDE Windows 系统 离线安装 esp32 开发板 亲测好用。

1、前提条件需要具备特殊网络。 2、官方文档地址&#xff1a;Installing - - — Arduino ESP32 latest documentation 3、系统&#xff1a;Windows10 Arduino IDE 版本2.3.3 之前安装的esp32开发板的版本是2.0.13&#xff0c;由于之前没有接触过esp32开发&#xff0c;也没…

期权懂|请问如何用期权进行风险管理?

期权小懂每日分享期权知识&#xff0c;帮助期权新手及时有效地掌握即市趋势与新资讯&#xff01; 请问如何用期权进行风险管理&#xff1f; 一、期权可以选择交易活跃的期权合约进行风险管理&#xff1a; 对于初级投资者来说&#xff0c;选择交易活跃的期权合约是非常重要的。…

GNU构建系统和Autotool

1、前言 经常使用Linux的开发人员或者运维人员&#xff0c;可能对configure->make->make install相当熟悉。事实上&#xff0c;这叫GNU构建系统&#xff0c;利用脚本和make程序在特定平台上构建软件。这种方式成为一种习惯&#xff0c;被广泛使用。本文从用户视角和开发…

NLP论文速读|ScPO:自我一致性的偏好优化(Self-Consistency Preference Optimization)

论文速读|Self-Consistency Preference Optimization 论文信息&#xff1a; 简介&#xff1a; 这篇论文试图解决的问题是如何在没有人类标注数据的情况下&#xff0c;提高大型语言模型&#xff08;LLMs&#xff09;在复杂推理任务上的性能。现有的自我对齐技术往往因为难以分配…

【前端学习指南】Vue computed 计算属性 watch 监听器

&#x1f36d; Hello&#xff0c;我是爱吃糖的范同学 &#x1f534; 想把自己学习技术的经历和一些总结分享给大家&#xff01; &#x1f534; 通过这样的方式记录自己成长&#xff0c;同时沉淀自己的技术&#xff0c;我会把所有额外的时间和经历投放到CSDN和公众号&#xff0…

自动驾驶合集(更新中)

文章目录 车辆模型控制路径规划 车辆模型 车辆模型基础合集 控制 控制合集 路径规划 规划合集

vcenter service基本异常处理

服务&#xff1a;vcenter service 版本&#xff1a; 7.0.3 问题描述&#xff1a;无法访问vcenter ui 排障思路&#xff1a; 1. 登入vcenter所在服务器执行基础排查&#xff1a;内存、cpu、磁盘、网络等&#xff0c;发现磁盘日志目录已经爆满&#xff0c;删除180天前的日志恢…

Background Tasks Kit(后台任务开发服务)

11_13日学习笔记 Background Tasks Kit&#xff08;后台任务开发服务&#xff09; Background Tasks Kit简介 设备返回主界面、锁屏、应用切换等操作会使应用退至后台。 应用退至后台后&#xff0c;如果继续活动&#xff0c;可能会造成设备耗电快、用户界面卡顿等现象。 为了…

modbus协议 Mthings模拟器使用

进制转换 HEX 16进制 (0、1、2、3、4、5、6、7、8、9、A、B、C、D、E、F表示0-15) dec 10进制 n(16进制) -> 10 abcd.efg(n) d*n^0 c*n^1 b*n^2 a*n^3 e*n^-1 f*n^-2 g*n^-3&#xff08;10&#xff09; 10 -> n(16进制) Modbus基础概念 高位为NUM_H&…

Python多进程间通讯(包含共享内存方式)

文章目录 1 通过非共享内存配合队列方式2 通过共享内存配合队列方式 注&#xff1a;本博文测试环境为Linux系统。 1 通过非共享内存配合队列方式 下面是一个常见的生产者与消费者的模式示例&#xff0c;这里分别启动了两个子进程&#xff0c;一个为生产者&#xff08;producer…

YOLOv11实战宠物狗分类

本文采用YOLOv11作为核心算法框架&#xff0c;结合PyQt5构建用户界面&#xff0c;使用Python3进行开发。YOLOv11以其高效的特征提取能力&#xff0c;在多个图像分类任务中展现出卓越性能。本研究针对5种宠物狗数据集进行训练和优化&#xff0c;该数据集包含丰富的宠物狗图像样本…

游戏引擎学习第八天

视频参考: https://www.bilibili.com/video/BV1ouUPYAErK/ 理解下面的代码 关于虚函数 代码分解 结构体 foo 的定义&#xff1a; struct foo {int32 X;int64 Y;virtual void Bar(int c); };foo 结构体有两个成员变量&#xff1a;X&#xff08;int32 类型&#xff09;和 Y&…

我要学kali-linux之shell脚本编程1

声明&#xff01; 学习视频来自B站up主 **泷羽sec** 有兴趣的师傅可以关注一下&#xff0c;如涉及侵权马上删除文章&#xff0c;笔记只是方便各位师傅的学习和探讨&#xff0c;文章所提到的网站以及内容&#xff0c;只做学习交流&#xff0c;其他均与本人以及泷羽sec团队无关&a…

尽量通俗易懂地概述.Net U nity跨语言/跨平台相关知识

本文参考来自唐老狮,Unity3D高级编程:主程手记,ai等途径 仅作学习笔记交流分享 目录 1. .Net是什么? 2. .Net框架的核心要点? 跨语言和跨平台 .Net x Unity跨平台发展史 Net Framework 2002 Unity跨平台之 Mono 2004 Unity跨平台之 IL2CPP 2015 二者区别 .NET Core …

大陆 ARS513 / ARS510 标准雷达(解析二)

1。GW_ACU (0x40) • GW_ACU_LongAccel Longitudinal acceleration of ego vehicle. • GW_ACU_LongAccel_ValidFlag Valid flag of signal “GW_ACU_LongAccel”. • GW_ACU_LateralAccel Lateral acceleration of ego vehicle. Signal quality requirements for “GW_ACU_La…

【游戏引擎之路】登神长阶(十四)——OpenGL教程:士别三日,当刮目相看

【游戏引擎之路】登神长阶&#xff08;十四&#xff09;——OpenGL教程&#xff1a;士别三日&#xff0c;当刮目相看 2024年 5月20日-6月4日&#xff1a;攻克2D物理引擎。 2024年 6月4日-6月13日&#xff1a;攻克《3D数学基础》。 2024年 6月13日-6月20日&#xff1a;攻克《3D…

【C++动态规划】2304. 网格中的最小路径代价|1658

本文涉及知识点 C动态规划 LeetCode2304. 网格中的最小路径代价 给你一个下标从 0 开始的整数矩阵 grid &#xff0c;矩阵大小为 m x n &#xff0c;由从 0 到 m * n - 1 的不同整数组成。你可以在此矩阵中&#xff0c;从一个单元格移动到 下一行 的任何其他单元格。如果你位…

数据中台解决方案

文件是关于数据中台解决方案的详细介绍&#xff0c;内容涵盖了数据中台的定义、建设方案、实施步骤、以及在数字化转型中的作用。以下是对文件内容的分析和总结&#xff1a; 1. 数字化转型背景 国家政策支持&#xff1a;提到了《中华人民共和国国民经济和社会发展第十四个五年…