Python快速入门-用解方程串联起其基础知识

于 2024-02-25 14:03:26 发布
阅读量1k 收藏 19
点赞数 21
文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59236602/article/details/136281785
版权

1python解方程

目标：Python快速入门-用解方程串联起其基础知识

  1. 串联方法：

  2. 建立一个知识容器

  3. 把知识放进容器

  4. 把容器的知识清空，然后把知识逐个装进容器。【让学习者更容易接受】

  5. 同样多的知识，有容器更容易传播。【手能拿的东西有限，若有一个容器则拿的更多】

  6. 知识容器：就是知识架构，其可以根据逻辑【自己的理解方式】，用思维导图等工具建立。

  7. 知识架构：串联知识的方式，一个完整的知识包含，是什么，为什么，怎么做。从会调库会用，到思考什么时候能用，为什么用，问题的本质到底是什么？

方法：Python实现求一元二次方程的解法

  1. 写代码，求解。
  2. 代码封装成函数，求解。
  3. 代码封装成类，求解。
  4. 添加异常处理，求解
  5. 代码封装成模块，求解。
  6. 安装第三方模块，求解。
  7. 如果这些开始不会写，但是通过网路检索，完成了那么你就算入门了。
  8. 发现问题，检索答案，验证，思考，总结。这些过程走一遍，能入门Python，也可入门其他。

三种方程的求解方法：

  1. 一元一次方程
  2. 二元一次方程
  3. 一元二次方程

1 一元一次方程

from sympy import symbols, Eq, solve

# 定义未知数
x = symbols('x')
# 定义方程
equation = Eq(2*x + 5, 11)
# 解方程
solution = solve(equation, x)
# 输出解
print("解为:", solution[0]) # 3

2 二元一次方程

from sympy import symbols, Eq, solve

# 定义未知数
x, y = symbols('x y')
# 定义线性方程组
equation1 = Eq(x + y, 8)
equation2 = Eq(x - y, 6)
# 解方程组
solution = solve((equation1, equation2), (x, y))
# 输出解
print("方程组的解为:", solution) #  {x: 7, y: 1}

3 一元二次方程

**一元二次方程的标准形式：**其中a、b、c是已知的常数，x是未知数。
{ax^2+bx+c=0 \quad (a\ne 0)}。 \\为方便求解，我们将方程两边同时除以 a ，的一元二次方程

x^2+\frac{b}{a}x+\frac{c}{a}=0。 \\

二次方程的求根公式推导过程：

方程两边都加上一次项系数 \frac{b}{2a} 的平方,即方程两边都加上 \frac{b2}{4a2} 得

x2+\frac{b}{a}x+\frac{b2}{4a2}=\frac{b2}{4a^2}－\frac{c}{a}

(x+\frac{b}{2a})2=\frac{b2-4ac}{4a^2}

x+\frac{b}{2a}=±\frac{ \sqrt{b^2-4ac} }{2a}

x=\frac{-b±\sqrt{b^2-4ac}}{2a}

高中学过复数，数的范围扩大了，和初中求解一元二次方程的方法不同。

代码实现：sympy 模块求解

########################################################
#调用第三方模块的函数解一元二次方程
########################################################
import sympy as sp

# 示例：解方程 x^2 - 8x + 12 = 0
x = sp.symbols('x')
solution = sp.solve(x**2 - 8*x + 12, x)
print("Solutions:", solution) # Solutions: [2, 6]

代码实现：手动实现

########################################################
# 手动实现，解一元二次方程
########################################################
import math

# 解方程 x^2 - 8x + 12 = 0
a, b, c = 1, -8, 12
if a == 0:
    print(f'您输入的不是二次方程!!!一次方程的解为x={c/b}')
else:
    # 计算判别式（discriminant）
    delta = b*b-4*a*c
    if delta == 0:
        # 有一个实根（重根）
        x = -b/(2*a)         
        print(f'方程有两个相等的实数根:x={x}')
    elif delta > 0:
        # 有两个实根
        x1 = (-b-math.sqrt(delta))/(2*a)
        x2 = (-b+math.sqrt(delta))/(2*a)
        print(f'方程有两个不同的实数根:x1={x1:.1f}, x2={x2:.2f}') 
    else:
        # print(f'方程无解') # 一下的代码是高中之后的知识。
        # delta < 0有两个虚根
        real_part = -b / (2*a)
        imaginary_part = math.sqrt(-delta) / (2*a)
        x1 = complex(real_part, imaginary_part)
        x2 = complex(real_part, -imaginary_part)
        print(f'方程有两个不同的虚数根:x1={x1:.1f}, x2={x2:.2f}')

一元二次方程对应的函数

一元二次方程对应的函数

代码实现

########################################################
# 一元二次方程对应的函数
########################################################
import matplotlib.pyplot as plt
import numpy as np
import sympy as sp

# 1 准备数据 y=f(x)
x = np.linspace(-1, 9, 100)  # 生成0到5之间的100个数据
a, b, c = 1, -8, 12
y = a * x ** 2 + b * x + c

# 2 绘制图形
plt.plot(x, y)  # 画图
plt.axhline(0, color='black', linewidth=0.5) # 绘制竖线
plt.axvline(0, color='black', linewidth=0.5) # 绘制横线
plt.title("一元二次函数", fontproperties="SimHei",fontsize=18, fontweight='bold')
plt.grid()
plt.legend(["y = x**2 - 6*x + 8"], loc='upper right')  # 添加图例

# 2绘制交点
# 解方程 x^2 - 8x + 12 = 0
x = sp.symbols('x')
y = a * x ** 2 + b * x + c
roots = sp.solve(y)
roots = np.array(roots)
# SymPy将符号表达式转换为Python函数
# 利用 lambdify 函数将 SymPy 表达式转换为 NumPy 可使用的函数
f = sp.lambdify(x, y, 'numpy')
# print(f(roots))
y_root = f(roots)
plt.scatter(roots, y_root, color='red', label="Roots")

# 3 显示
plt.show()

2基础知识

  1. 变量：定义变量
  2. 运算符：数学计算
  3. 数据类型：复数，整数

在Python中我们也要定义变量。我们可以把变量看成是一个未知数x，x = 5

代码实现

########################################################
# 手动实现，解一元二次方程
########################################################
import math

# 1 变量：定义变量；3数据类型--------------------------
# 解方程 x^2 - 8x + 12 = 0
a, b, c = 1, -8, 12
if a == 0:
    print(f'您输入的不是二次方程!!!一次方程的解为x={c/b}')
else:
    # 计算判别式（discriminant）
    # 2 运算符：数学计算--------------------------
    delta = b*b-4*a*c
    if delta == 0:
        # 有一个实根（重根）
        x = -b/(2*a)         
        print(f'方程有两个相等的实数根:x={x}')
    elif delta > 0:
        # 有两个实根
        x1 = (-b-math.sqrt(delta))/(2*a)
        x2 = (-b+math.sqrt(delta))/(2*a)
        print(f'方程有两个不同的实数根:x1={x1:.1f}, x2={x2:.2f}') 
    else:
        # print(f'方程无解') # 一下的代码是高中之后的知识。
        # delta < 0有两个虚根
        real_part = -b / (2*a)
        imaginary_part = math.sqrt(-delta) / (2*a)
        # 3 数据类型：复数--------------------------
        x1 = complex(real_part, imaginary_part)
        x2 = complex(real_part, -imaginary_part)
        print(f'方程有两个不同的虚数根:x1={x1:.1f}, x2={x2:.2f}')

3控制语句

**控制语句有三种，**顺序，判断，循环。

顺序语句：解一元二次方程，先求判别式 delta = b*b-4*a*c，再求根。

代码实现：判断语句

########################################################
# 手动实现，解一元二次方程
########################################################
import math

# 解方程 x^2 - 8x + 12 = 0
a, b, c = 1, -8, 12
if a == 0:
    print(f'您输入的不是二次方程!!!一次方程的解为x={c/b}')
else:
    # 计算判别式（discriminant）
    delta = b*b-4*a*c
    # 控制语句--------------------
    if delta == 0:
        # 有一个实根（重根）
        x = -b/(2*a)         
        print(f'方程有两个相等的实数根:x={x}')
    elif delta > 0:
        # 有两个实根
        x1 = (-b-math.sqrt(delta))/(2*a)
        x2 = (-b+math.sqrt(delta))/(2*a)
        print(f'方程有两个不同的实数根:x1={x1:.1f}, x2={x2:.2f}') 
    else:
        # print(f'方程无解') # 一下的代码是高中之后的知识。
        # delta < 0有两个虚根
        real_part = -b / (2*a)
        imaginary_part = math.sqrt(-delta) / (2*a)
        x1 = complex(real_part, imaginary_part)
        x2 = complex(real_part, -imaginary_part)
        print(f'方程有两个不同的虚数根:x1={x1:.1f}, x2={x2:.2f}')

输出二次方程对应的二次函数的x, y

代码实现：循环语句

########################################################
# 输出二次函数对应的x, y
########################################################
def quadratic_equation(x, a, b, c):
    """定义二次函数
    参数：未知数x,二次方程的系数a,b,c    """
    return a*x**2 + b*x + c

# 定义二次方程的系数
a = 1
b = -8
c = 12
# 循环语句--------------------
for x in range(10):
    y = quadratic_equation(x, 1, -3, 2)
    print(f"For x = {x}, y = {y}")

4函数

函数概述

**函数：**完成一个特定功能的一段代码。其类似于数学中的函数。函数分为三类：

  1. 内置函数
  2. 模块中的函数（内置模块和第三方模块）
  3. 自定义函数

1内置函数

内置函数，可以直接使用，如print，常用内置函数如下：

########################################################
# 内置函数运算操作
########################################################
list_data = [1, 2, 3, 4, 5, 66, 7, 8, 9, 10]
print(sum(list_data))
print(min(list_data))
print(max(list_data))
print(len(list_data))
print(pow(3, 2))

2内置模块中的函数

########################################################
# 内置模块运算操作
########################################################
import math
print(dir(math))        # 查看模块中的所有函数
print(help(math.pow))   # 查看模块中函数的的使用
print(math.pow(-5, 2))  # 平方函数 (-5)**2=25
print(math.pi)          # 模块中的数据 pi,3.1415
print(math.sqrt(25))    # 开方函数

3自定义函数

定义解一元二次方程的函数

########################################################
# 自定义函数，解一元二次方程
########################################################
import math
def solve_equation(a, b, c):
   ''' 解二元一次方程的函数 '''
   if a == 0:
        print(f'您输入的不是二次方程!!!一次方程的解为x={c/b}')
   else:
    # 计算判别式（discriminant）
    delta = b*b-4*a*c
    if delta == 0:
        # 有一个实根（重根）
        x = -b/(2*a)         
        print(f'方程有两个相等的实数根:x={x}')
        return x
    elif delta > 0:
        # 有两个实根
        x1 = (-b-math.sqrt(delta))/(2*a)
        x2 = (-b+math.sqrt(delta))/(2*a)
        print(f'方程有两个不同的实数根:x1={x1:.1f}, x2={x2:.2f}')
        return x1, x2
    else:
        # print(f'方程无解') # 一下的代码是高中之后的知识。
        # delta < 0有两个虚根
        real_part = -b / (2*a)
        imaginary_part = math.sqrt(-delta) / (2*a)
        x1 = complex(real_part, imaginary_part)
        x2 = complex(real_part, -imaginary_part)
        print(f'方程有两个不同的虚数根:x1={x1:.1f}, x2={x2:.2f}')

solve_equation(0, -2, 6) # 您输入的不是二次方程!一次方程的解为，x=-3.0
solve_equation(1, -2, 1) # 方程有两个相等的实数根:x=1.0
solve_equation(1, -8, 12) # 方程有两个不同的实数根:x1=2.0, x2=6.00
solve_equation(1, -2, 2) # 方程有两个不同的虚数根:x1=1.0+1.0j, x2=1.00-1.00j

代码实现：第三方模块sympy 模块求解

########################################################
#调用第三方模块的函数解一元二次方程
########################################################
import sympy as sp

# 解方程 x^2 - 8x + 12 = 0
x = sp.symbols('x')
solution = sp.solve(x**2 - 8*x + 12, x)
print("Solutions:", solution) # Solutions: [2, 6]

5面向对象

面向对象编程提供模块化和可维护的代码结构

  1. 属性和方法的定义
  2. 面向对象的特性：封装继承多态
  3. 面向对象和面向过程的区别

1 属性和方法的定义

  1. 属性：放在类里面的变量
  2. 方法：放在类里面的函数

2 面向对象的特性：封装继承多态

  1. 封装：将数据和操作封装在一个类中。在这个例子中，我们将封装一元二次方程的求解方法。
  2. 继承：一个类继承另一个类的特征。创建一个基类，并在子类中重写求解方法，实现多态。
  3. 多态：使用具有相同名称但不同实现的方法。在这里，将演示不同的求解方法

代码实现：简单版，封装

import math

class QuadraticEquation:
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c
    
    def solve(self):
        delta = self.b ** 2 - 4 * self.a * self.c
        
        if delta > 0:
            x1 = (-self.b + math.sqrt(delta)) / (2 * self.a)
            x2 = (-self.b - math.sqrt(delta)) / (2 * self.a)
            print(f'方程有两个不同的实数根:x1={x1:.1f}, x2={x2:.2f}')
            return x1, x2
        elif delta == 0:
            x = -self.b / (2 * self.a)
            print(f'方程有两个相等的实数根:x={x}')
            return x
        else:
            # print(f'方程无解') # 一下的代码是高中之后的知识。
            # delta < 0有两个虚根
            real_part = -self.b / (2 * self.a)
            imaginary_part = math.sqrt(-delta) / (2 * self.a)
            x1 = complex(real_part, imaginary_part)
            x2 = complex(real_part, -imaginary_part)
            print(f'方程有两个不同的虚数根:x1={x1:.1f}, x2={x2:.2f}')
            return x1, x2

# 使用这个类来解方程 a = 1, b = -8, c = 12
equation_solver = QuadraticEquation(1, -8, 12)  
roots = equation_solver.solve()
print("方程的根是:", roots)

代码实现：封装继承多态

import math

class Equation:
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c
    
    def solve(self):
        pass

class QuadraticEquation(Equation):    
    def solve(self):
        delta = self.b ** 2 - 4 * self.a * self.c
        
        if delta > 0:
            x1 = (-self.b + math.sqrt(delta)) / (2 * self.a)
            x2 = (-self.b - math.sqrt(delta)) / (2 * self.a)
            print(f'方程有两个不同的实数根:x1={x1:.1f}, x2={x2:.2f}')
            return x1, x2
        elif delta == 0:
            x = -self.b / (2 * self.a)
            print(f'方程有两个相等的实数根:x={x}')
            return x
        else:
            # print(f'方程无解') # 一下的代码是高中之后的知识。
            # delta < 0有两个虚根
            real_part = -self.b / (2 * self.a)
            imaginary_part = math.sqrt(-delta) / (2 * self.a)
            x1 = complex(real_part, imaginary_part)
            x2 = complex(real_part, -imaginary_part)
            print(f'方程有两个不同的虚数根:x1={x1:.1f}, x2={x2:.2f}')
            return x1, x2

class LinearEquation(Equation):
    def solve(self):
        if self.b == 0:
            if self.c == 0:
                print("无穷多解")
                return "无穷多解"
            else:
                print("无解")
                return "无解"
        else:
            print(f'一次方程的解为x={-self.c / self.b}')
            return -self.c / self.b
        
# 使用这个类来解方程 x^2 - 8x + 12 = 0
equation_solver = QuadraticEquation(1, -8, 12)  
roots = equation_solver.solve()
print("一元二次方程的根:", roots)

# 使用这个类来解方程 - 8x + 12 = 0
linear_solver = LinearEquation(0, -8, 12)  
root = linear_solver.solve()
print("一元一次方程的根:", root)

6文件操作

内容概述

  1. 文件读写的两种模型
  2. with语句

1 文件读写的两种模型

  1. **文件不存在：**1新建文件，2写入信息，3关闭保存文件

  2. 文件存在：1打开文件，2读取信息， 3关闭文件

  3. **open() 函数：**常用形式是接收两个参数文件名(file)和模式(mode)

  4. r ，只读模式【默认模式，文件必须存在，不存在则抛出异常】

  5. w，只写模式【不可读；不存在则创建**；存在则清空内容**】

  6. a，只读追加写模式【不可读；不存在则创建；存在则只追加内容】

  7. + 表示可以同时读写某个文件

  8. r+， 读写【可读，可写】

  9. w+，写读【可读，可写】

  10. a+， 写读【可读，可写】

为了方便演示，这里用了w，只写模式；为了文件的安全，最好修改成a，只读追加写模式。

############################################# 
# 读写的两种操作模型
############################################# 
# 文件不存在 1新建文件，2写入信息、3关闭保存文件
# 1 创建文件
data_file = open('love_study.txt', 'w') 
str1 = "love makes the world go round!  "
str2 = "good good study day day up! "
# 2 写入文件
line = data_file.write(str1) 
line = data_file.write(str2) #写入文件
# 3 关闭保存文件
data_file.close() 

# 文件存在 1打开文件，2读取信息， 3关闭文件
# 1 打开文件
fo = open("love_study.txt", "r") #读取文件
# 2 读取文件
line = fo.read()
print ("读取的字符串: %s" % (line))
# 3 关闭文件
fo.close()

2 with语句

  1. with语句使代码更清晰、更具可读性， 它简化了文件读写的流程；
  2. with关键字系统会自动调用 f.close() 方法；
########################################################
#调用第三方模块的函数解一元二次方程，并保存到文件中
########################################################
import sympy as sp

# 示例：解方程 x^2 - 8x + 12 = 0
x = sp.symbols('x')
roots = sp.solve(x**2 - 8*x + 12, x)
print("Roots:", roots) # Solutions: [2, 6]

# 保存数据到文件
with open("quadratic_roots.txt", "w") as file:
    if isinstance(roots, tuple):
        file.write(f"Root 1: {roots[0]}\nRoot 2: {roots[1]}")
    else:
        file.write(f"Root: {roots}")

# 从文件中读取数据
# 1 打开文件
fo = open("quadratic_roots.txt", "r") #读取文件
# 2 读取文件
line = fo.read()
print ("读取的字符串: %s" % (line))
# 3 关闭文件
fo.close()

7异常处理

使用try-except语句处理潜在的错误或异常情况

异常处理概述：

  1. 三种错误
  2. 异常处理

1三种错误

  1. 语法错误，比如少写了一个引号。指开发人员编写了不符合Python语法的代码所引起的错误。

  2. 运行时错误，比如用一个数去除以零。代码运行期间发生的错误称为异常或运行时错误。

  3. 逻辑错误，比如相等符号写成了赋值符号。逻辑错误发生时程序会顺利运行，但得到的结果不符合期望。

  4. 常见的错误

  5. IndentationError：缩进错误

  6. SyntaxError：语法错误

  7. invalid character in identifier：可能输入中文符号。

2异常处理

异常处理概述：处理可能出错的代码，增加程序的健壮性

########################################################
# 除法函数的异常处理操作
######################################################## 
def divide(x, y):
   '''除法'''
   try:
      print("1可能发生异常的代码")
      result = x / y
   except ZeroDivisionError as err:# 
      print("2发生异常时执行的代码")
      print('2发生异常时执行的代码，异常是', err)
   except:
      print("2发生异常时执行的代码，发生未知错误")
   else:
      print("3没有发生异常执行的代码！")
   finally:   
      print("4非必需代码，不管是否有异常都会执行！")
   print("我是正常代码！")

divide(2, 1)
print("------------------")
divide(2, 0)
print("------------------")
divide(2, 'a')

代码实现：求一元二次方程的根，添加异常处理

########################################################
# 自定义函数，解一元二次方程，添加异常处理
########################################################
import math
def solve_equation(a, b, c):
    try:
        if a == 0:
                print(f'您输入的不是二次方程!!!一次方程的解为x={c/b}')
        else:
            # 计算判别式（discriminant）
            delta = b*b-4*a*c
            if delta == 0:
                # 有一个实根（重根）
                x = -b/(2*a)         
                print(f'方程有两个相等的实数根:x={x}')
                return x
            elif delta > 0:
                # 有两个实根
                x1 = (-b-math.sqrt(delta))/(2*a)
                x2 = (-b+math.sqrt(delta))/(2*a)
                print(f'方程有两个不同的实数根:x1={x1:.1f}, x2={x2:.2f}')
                return x1, x2
            else:
                # print(f'方程无解') # 一下的代码是高中之后的知识。
                # delta < 0有两个虚根
                real_part = -b / (2*a)
                imaginary_part = math.sqrt(-delta) / (2*a)
                x1 = complex(real_part, imaginary_part)
                x2 = complex(real_part, -imaginary_part)
                print(f'方程有两个不同的虚数根:x1={x1:.1f}, x2={x2:.2f}')
    except TypeError as e:
        print(f"发生错误：{e}")

solve_equation(0, -2, 6) # 您输入的不是二次方程!一次方程的解为，x=-3.0
solve_equation(1, -2, 1) # 方程有两个相等的实数根:x=1.0
solve_equation(1, -8, 12) # 方程有两个不同的实数根:x1=2.0, x2=6.00
solve_equation(1, -2, 2) # 方程有两个不同的虚数根:x1=1.0+1.0j, x2=1.00-1.00j
# 输入的a不是数字时，报错
solve_equation("a", -3, 2)

8模块

通过模块化代码提高可重用性和可维护性

模块概述，若用模块和手机做对比，手机安装软件，可以实现更多功能，python安装模块，也可以。

  1. 内置模块，类似于手机自带软件，闹钟，电话**（功能有限只能打电话）；需要引用，才能使用。**
  2. 第三方模块，类似于手机需安装的软件，微信（文字，语音，视频都可以）；需要安装+引用，才能使用。
  3. 自定义模块，类似于自定义功能（自定义闹钟：闹钟+闹钟音乐为自己的录音“再睡一会再睡一会”）；需要引用，才能使用。

1 内置模块

使用方式：参考第四章函数中，内置模块中的函数。

2 第三方模块

sympy.solve()函数解一元二次方程 ax^{2}+bx+c=0的根

########################################################
#调用第三方模块的函数解一元二次方程
########################################################
import sympy

x = sympy.Symbol('x')
a = 1
b = -8
c = 12
slove = sympy.solve(a*x**2 + b*x + c)
print(slove)

3 自定义模块

my_module.py文件就是一个模块，你可以在里面自定义数据，函数，类

在文件中定义一个模块

文件名：my_module.py

def solve_equation(a, b, c):
    pass

在其他地方使用模块

from my_module import solve_equation
result = solve_equation(0, -2, 6)

9总结与参考

时间：2023年11月17日17:47:20

编程的本质：数据和函数

  1. 变量+运算符+控制语句–》函数–》类–》模块
  2. 变量存储数据
  3. 数据：字符，数字，文本，图片，音频，视频。

Python实现求一元二次方程的解法

  1. 写代码，求解。
  2. 代码封装成函数，求解。
  3. 代码封装成类，求解。
  4. 添加异常处理，求解
  5. 代码封装成模块，求解。
  6. 安装第三方模块，求解。

以上就是“Python快速入门-用解方程串联起其基础知识”的全部内容，希望对你有所帮助。
​
​关于Python技术储备

学好 Python 不论是就业还是做副业赚钱都不错，但要学会 Python 还是要有一个学习规划。最后大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！

一、Python所有方向的学习路线

Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

在这里插入图片描述

二、Python必备开发工具

img

三、Python视频合集

观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。

img

四、实战案例

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

img

五、Python练习题

检查学习结果。

img

六、面试资料

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

img

最后祝大家天天进步！！

上面这份完整版的Python全套学习资料已经上传至CSDN官方，朋友如果需要可以直接微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】。

可口可乐没有乐
关注
  • 21
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值