pandas（合并concat和merge）

最新推荐文章于 2025-06-17 16:11:31 发布
最新推荐文章于 2025-06-17 16:11:31 发布
阅读量9.1k 收藏 20
点赞数 3
分类专栏： python学习
本文详细介绍了Pandas库中处理数据合并的三种方法：concat、append和merge，包括它们的基本用法、参数调整以及如何根据需求选择合适的合并方式。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

pandas处理多组数据的时候往往会要用到数据的合并处理，其中有三种方式，concat、append和merge。

1、concat

用concat是一种基本的合并方式。而且concat中有很多参数可以调整，合并成你想要的数据形式。axis来指明合并方向。axis=0是预设值，因此未设定任何参数时，函数默认axis=0。（0表示上下合并，1表示左右合并）

  1. import pandas as pd
  2. import numpy as np
  3.  
  4. #定义资料集
  5. df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'])
  6. df2 = pd.DataFrame(np.ones((3,4))*1, columns=['a','b','c','d'])
  7. df3 = pd.DataFrame(np.ones((3,4))*2, columns=['a','b','c','d'])
  8.  
  9. #concat纵向合并
  10. res = pd.concat([df1, df2, df3], axis=0)
  11.  
  12. #打印结果
  13. print(res)
  14. '''
  15.      a    b    c    d
  16. 0  0.0  0.0  0.0  0.0
  17. 1  0.0  0.0  0.0  0.0
  18. 2  0.0  0.0  0.0  0.0
  19. 0  1.0  1.0  1.0  1.0
  20. 1  1.0  1.0  1.0  1.0
  21. 2  1.0  1.0  1.0  1.0
  22. 0  2.0  2.0  2.0  2.0
  23. 1  2.0  2.0  2.0  2.0
  24. 2  2.0  2.0  2.0  2.0
  25. '''

上述index为0，1，2，0，1，2形式。为什么会出现这样的情况，其实是仍然按照合并前的index组合起来的。若希望递增，请看下面示例：

ignore_index (重置 index)

重置后的index为0，1，……8

  1. res = pd.concat([df1, df2, df3], axis=0, ignore_index=True)# 将ignore_index设置为True
  2.  
  3. print(res)        #打印结果
  4. '''
  5.      a    b    c    d
  6. 0  0.0  0.0  0.0  0.0
  7. 1  0.0  0.0  0.0  0.0
  8. 2  0.0  0.0  0.0  0.0
  9. 3  1.0  1.0  1.0  1.0
  10. 4  1.0  1.0  1.0  1.0
  11. 5  1.0  1.0  1.0  1.0
  12. 6  2.0  2.0  2.0  2.0
  13. 7  2.0  2.0  2.0  2.0
  14. 8  2.0  2.0  2.0  2.0
  15. '''

join （合并方式）

join='outer'为预设值，因此未设定任何参数时，函数默认join='outer'。此方式是依照column来做纵向合并，有相同的column上下合并在一起，其他独自的column个自成列，原本没有值的位置皆以NaN填充。

  1. import pandas as pd
  2. import numpy as np
  3.  
  4. #定义资料集
  5. df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'], index=[1,2,3])
  6. df2 = pd.DataFrame(np.ones((3,4))*1, columns=['b','c','d','e'], index=[2,3,4])
  7.  
  8. res = pd.concat([df1, df2], axis=0, join='outer')   #纵向"外"合并df1与df2
  9.  
  10. print(res)
  11. '''
  12.      a    b    c    d    e
  13.  1  0.0  0.0  0.0  0.0  NaN
  14.  2  0.0  0.0  0.0  0.0  NaN
  15.  3  0.0  0.0  0.0  0.0  NaN
  16.  2  NaN  1.0  1.0  1.0  1.0
  17.  3  NaN  1.0  1.0  1.0  1.0
  18.  4  NaN  1.0  1.0  1.0  1.0
  19. '''
  20. res = pd.concat([df1, df2], axis=0, join='inner')   #纵向"内"合并df1与df2
  21.  
  22. #打印结果
  23. print(res)
  24. '''
  25.      b    c    d
  26.  1  0.0  0.0  0.0
  27.  2  0.0  0.0  0.0
  28.  3  0.0  0.0  0.0
  29.  2  1.0  1.0  1.0
  30.  3  1.0  1.0  1.0
  31.  4  1.0  1.0  1.0
  32. '''

join_axes (依照 axes 合并)

  1. import pandas as pd
  2. import numpy as np
  3.  
  4. #定义资料集
  5. df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'], index=[1,2,3])
  6. df2 = pd.DataFrame(np.ones((3,4))*1, columns=['b','c','d','e'], index=[2,3,4])
  7.  
  8. #依照`df1.index`进行横向合并
  9. res = pd.concat([df1, df2], axis=1, join_axes=[df1.index])
  10.  
  11. #打印结果
  12. print(res)
  13. #     a    b    c    d    b    c    d    e
  14. # 1  0.0  0.0  0.0  0.0  NaN  NaN  NaN  NaN
  15. # 2  0.0  0.0  0.0  0.0  1.0  1.0  1.0  1.0
  16. # 3  0.0  0.0  0.0  0.0  1.0  1.0  1.0  1.0

上述脚本中，join_axes=[df1.index]表明按照df1的index来合并，可以看到结果中去掉了df2中出现但df1中没有的index=4这一行。

2、append (添加数据) 

append只有纵向合并，没有横向合并。

  1. import pandas as pd
  2. import numpy as np
  3.  
  4. #定义资料集
  5. df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'])
  6. df2 = pd.DataFrame(np.ones((3,4))*1, columns=['a','b','c','d'])
  7. df3 = pd.DataFrame(np.ones((3,4))*1, columns=['a','b','c','d'])
  8. s1 = pd.Series([1,2,3,4], index=['a','b','c','d'])
  9.  
  10. #将df2合并到df1的下面，以及重置index，并打印出结果
  11. res = df1.append(df2, ignore_index=True)
  12. print(res)
  13. #     a    b    c    d
  14. # 0  0.0  0.0  0.0  0.0
  15. # 1  0.0  0.0  0.0  0.0
  16. # 2  0.0  0.0  0.0  0.0
  17. # 3  1.0  1.0  1.0  1.0
  18. # 4  1.0  1.0  1.0  1.0
  19. # 5  1.0  1.0  1.0  1.0
  20.  
  21. #合并多个df，将df2与df3合并至df1的下面，以及重置index，并打印出结果
  22. res = df1.append([df2, df3], ignore_index=True)
  23. print(res)
  24. #     a    b    c    d
  25. # 0  0.0  0.0  0.0  0.0
  26. # 1  0.0  0.0  0.0  0.0
  27. # 2  0.0  0.0  0.0  0.0
  28. # 3  1.0  1.0  1.0  1.0
  29. # 4  1.0  1.0  1.0  1.0
  30. # 5  1.0  1.0  1.0  1.0
  31. # 6  1.0  1.0  1.0  1.0
  32. # 7  1.0  1.0  1.0  1.0
  33. # 8  1.0  1.0  1.0  1.0
  34.  
  35. #合并series，将s1合并至df1，以及重置index，并打印出结果
  36. res = df1.append(s1, ignore_index=True)
  37. print(res)
  38. #     a    b    c    d
  39. # 0  0.0  0.0  0.0  0.0
  40. # 1  0.0  0.0  0.0  0.0
  41. # 2  0.0  0.0  0.0  0.0
  42. # 3  1.0  2.0  3.0  4.0

3、merge

根据两组数据中的关键字key来合并（key在两组数据中是完全一致的）。

3.1依据一组key合并

  1. import pandas as pd
  2.  
  3. #定义资料集并打印出
  4. left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
  5.                              'A': ['A0', 'A1', 'A2', 'A3'],
  6.                              'B': ['B0', 'B1', 'B2', 'B3']})
  7. right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
  8.                               'C': ['C0', 'C1', 'C2', 'C3'],
  9.                               'D': ['D0', 'D1', 'D2', 'D3']})
  10.  
  11. print(left)
  12. #    A   B key
  13. # 0  A0  B0  K0
  14. # 1  A1  B1  K1
  15. # 2  A2  B2  K2
  16. # 3  A3  B3  K3
  17.  
  18. print(right)
  19. #    C   D key
  20. # 0  C0  D0  K0
  21. # 1  C1  D1  K1
  22. # 2  C2  D2  K2
  23. # 3  C3  D3  K3
  24.  
  25. #依据key column合并，并打印出
  26. res = pd.merge(left, right, on='key')
  27.  
  28. print(res)
  29.      A   B key   C   D
  30. # 0  A0  B0  K0  C0  D0
  31. # 1  A1  B1  K1  C1  D1
  32. # 2  A2  B2  K2  C2  D2
  33. # 3  A3  B3  K3  C3  D3

3.2 根据两组key合并

合并时有4种方法how = ['left', 'right', 'outer', 'inner']，预设值how='inner'。

  • inner:按照关键字组合之后，去掉组合中有合并项为NaN的行。
  • outer ：保留所有组合
  • left：仅保留左边合并项为NaN的行
  • right：仅保留右边合并项为NaN的行
  1. import pandas as pd
  2. import numpy as np
  3.  
  4. #定义资料集并打印出
  5. left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
  6.                       'key2': ['K0', 'K1', 'K0', 'K1'],
  7.                       'A': ['A0', 'A1', 'A2', 'A3'],
  8.                       'B': ['B0', 'B1', 'B2', 'B3']})
  9. right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
  10.                        'key2': ['K0', 'K0', 'K0', 'K0'],
  11.                        'C': ['C0', 'C1', 'C2', 'C3'],
  12.                        'D': ['D0', 'D1', 'D2', 'D3']})
  13.  
  14. print(left)
  15. '''
  16.   key1 key2   A   B
  17. 0   K0   K0  A0  B0
  18. 1   K0   K1  A1  B1
  19. 2   K1   K0  A2  B2
  20. 3   K2   K1  A3  B3
  21. '''
  22. print(right)
  23. '''
  24.   key1 key2   C   D
  25. 0   K0   K0  C0  D0
  26. 1   K1   K0  C1  D1
  27. 2   K1   K0  C2  D2
  28. 3   K2   K0  C3  D3
  29. '''
  30.  
  31. #依据key1与key2 columns进行合并，并打印出四种结果['left', 'right', 'outer', 'inner']
  32. res = pd.merge(left, right, on=['key1', 'key2'], how='inner')
  33. print(res)
  34. '''
  35.   key1 key2   A   B   C   D
  36. 0   K0   K0  A0  B0  C0  D0
  37. 1   K1   K0  A2  B2  C1  D1
  38. 2   K1   K0  A2  B2  C2  D2
  39. '''
  40. res = pd.merge(left, right, on=['key1', 'key2'], how='outer')
  41. print(res)
  42. '''
  43.   key1 key2    A    B    C    D
  44. 0   K0   K0   A0   B0   C0   D0
  45. 1   K0   K1   A1   B1  NaN  NaN
  46. 2   K1   K0   A2   B2   C1   D1
  47. 3   K1   K0   A2   B2   C2   D2
  48. 4   K2   K1   A3   B3  NaN  NaN
  49. 5   K2   K0  NaN  NaN   C3   D3
  50. '''
  51. res = pd.merge(left, right, on=['key1', 'key2'], how='left')
  52. print(res) 
  53. '''
  54.   key1 key2   A   B    C    D
  55. 0   K0   K0  A0  B0   C0   D0
  56. 1   K0   K1  A1  B1  NaN  NaN
  57. 2   K1   K0  A2  B2   C1   D1
  58. 3   K1   K0  A2  B2   C2   D2
  59. 4   K2   K1  A3  B3  NaN  NaN
  60. '''
  61. res = pd.merge(left, right, on=['key1', 'key2'], how='right')
  62. print(res) 
  63. '''
  64.   key1 key2    A    B   C   D
  65. 0   K0   K0   A0   B0  C0  D0
  66. 1   K1   K0   A2   B2  C1  D1
  67. 2   K1   K0   A2   B2  C2  D2
  68. 3   K2   K0  NaN  NaN  C3  D3
  69. '''

3.3 Indicator

indicator=True会将合并的记录放在新的一列。

  1. import pandas as pd
  2.  
  3. #定义资料集并打印出
  4. df1 = pd.DataFrame({'col1':[0,1], 'col_left':['a','b']})
  5. df2 = pd.DataFrame({'col1':[1,2,2],'col_right':[2,2,2]})
  6.  
  7. print(df1)
  8. #   col1 col_left
  9. # 0     0        a
  10. # 1     1        b
  11.  
  12. print(df2)
  13. #   col1  col_right
  14. # 0     1          2
  15. # 1     2          2
  16. # 2     2          2
  17.  
  18. # 依据col1进行合并，并启用indicator=True，最后打印出
  19. res = pd.merge(df1, df2, on='col1', how='outer', indicator=True)
  20. print(res)
  21. #   col1 col_left  col_right      _merge
  22. # 0   0.0        a        NaN   left_only
  23. # 1   1.0        b        2.0        both
  24. # 2   2.0      NaN        2.0  right_only
  25. # 3   2.0      NaN        2.0  right_only
  26.  
  27. # 自定indicator column的名称，并打印出
  28. res = pd.merge(df1, df2, on='col1', how='outer', indicator='indicator_column')
  29. print(res)
  30. #   col1 col_left  col_right indicator_column
  31. # 0   0.0        a        NaN        left_only
  32. # 1   1.0        b        2.0             both
  33. # 2   2.0      NaN        2.0       right_only
  34. # 3   2.0      NaN        2.0       right_only

3.4 依据index合并

  1. import pandas as pd
  2.  
  3. #定义资料集并打印出
  4. left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
  5.                      'B': ['B0', 'B1', 'B2']},
  6.                      index=['K0', 'K1', 'K2'])
  7. right = pd.DataFrame({'C': ['C0', 'C2', 'C3'],
  8.                       'D': ['D0', 'D2', 'D3']},
  9.                      index=['K0', 'K2', 'K3'])
  10.  
  11. print(left)
  12. #     A   B
  13. # K0  A0  B0
  14. # K1  A1  B1
  15. # K2  A2  B2
  16.  
  17. print(right)
  18. #     C   D
  19. # K0  C0  D0
  20. # K2  C2  D2
  21. # K3  C3  D3
  22.  
  23. #依据左右资料集的index进行合并，how='outer',并打印出
  24. res = pd.merge(left, right, left_index=True, right_index=True, how='outer')
  25. print(res)
  26. #      A    B    C    D
  27. # K0   A0   B0   C0   D0
  28. # K1   A1   B1  NaN  NaN
  29. # K2   A2   B2   C2   D2
  30. # K3  NaN  NaN   C3   D3
  31.  
  32. #依据左右资料集的index进行合并，how='inner',并打印出
  33. res = pd.merge(left, right, left_index=True, right_index=True, how='inner')
  34. print(res)
  35. #     A   B   C   D
  36. # K0  A0  B0  C0  D0
  37. # K2  A2  B2  C2  D2

3.5 解决overlapping的问题

下面脚本中，boys和girls均有属性age，但是两者值不同，因此需要在合并时加上后缀suffixes，以示区分。
  1. import pandas as pd
  2.  
  3. #定义资料集
  4. boys = pd.DataFrame({'k': ['K0', 'K1', 'K2'], 'age': [1, 2, 3]})
  5. girls = pd.DataFrame({'k': ['K0', 'K0', 'K3'], 'age': [4, 5, 6]})
  6.  
  7. #使用suffixes解决overlapping的问题
  8. res = pd.merge(boys, girls, on='k', suffixes=['_boy', '_girl'], how='inner')
  9. print(res)
  10. #    age_boy   k  age_girl
  11. # 0        1  K0         4
  12. # 1        1  K0         5

以上是pandas中有关于合并的一些操作。当然，如果练习的多了，几个方法也是大同小异。

Pandas - 4. 组合 concat 和 merge
Aaron_ChenShenyu的博客
05-22 513
concat()函数 当相同类型的表被分成好多个部分，需要将各部分按行或按列连接 按行连接 concat，可以连接多个 append，只追加单个 import pandas as pd df1 = pd.read_csv('data/concat_1.csv') df2 = pd.read_csv('data/concat_2.csv') df3 = pd.read_csv('data/concat_3.csv') print(df1) print(df2) print(df3) A
发现一个pandas种concat和merge的区别
人太健忘了，需要有个地方记录
04-01 347
pandas中，concat和merge都可以用来拼接数据，但是这两个方法有什么区别呢，常规的区别今天暂且不提，主要分享一个我近期发现的区别，主要是针对两个df有重名的列的情况，先看concat。可以看到，merge会对同名的列进行重命名，而且不论是第一个df，还是第二个df，名字都会被改变，而且规则是，左边的df名字会被加_x,右边的df会加_y。可以看到，当两个df有同名的列的时候，concat不会做任何处理，之前是什么名字，拼接后还是什么名字，再看merge。
python3：pandas（合并concat和merge）
sunshine_lyn的博客
08-09 9611
pandas处理多组数据的时候往往会要用到数据的合并处理，其中有三种方式，concat、append和merge。 1、concat 用concat是一种基本的合并方式。而且concat中有很多参数可以调整，合并成你想要的数据形式。axis来指明合并方向。axis=0是预设值，因此未设定任何参数时，函数默认axis=0。（0表示上下合并，1表示左右合并） import pandas as ...
Pandas中merge、concat、join 区别 ！！
最新发布
一个不怎么正经的算法工程师的博客~不定期更新一些我所覆盖领域的干货~~~包你满意噢~~
06-17 1177
详细解释了Pandas提供了三种数据合并方法：merge基于键连接数据（类似SQL JOIN），concat沿轴堆叠对象（无视连接键），join基于索引或列合并。merge最灵活但性能较差，concat适用于相同结构数据的高效堆叠，join擅长索引对齐的快速合并。实际应用中应根据数据结构、连接需求和性能考虑选择合适方法：复杂键连接用merge，简单堆叠用concat，索引对齐用join。优化技巧包括设置索引、过滤数据、一次合并等，合并时可通过suffixes处理重复列名。掌握三者差异可提升数据处理效率。
pandas数据的合并concat()和merge()
蓝小白的博客
02-26 7620
import pandas as pd 轴向连接(concatenation): pd.concat() 可以沿一个轴将多个DataFrame对象连接在一起, 形成一个新的Dataframe对象 融合（merging）：pd.merge()方法可以根据一个或多个键将不同DataFrame中的行连接起来。 concat() 轴向连接 concat() 函数可以将数据根据不同的轴作进行合并 pd.concat(objs, axis=0, join='outer') objs: series、da
pandas的concat、merge函数、处理数据
leshen_88的博客
01-19 2406
pandas的concat()函数用于连接（合并）pandas对象，如Series、DataFrame或Panel，沿指定的轴进行连接。函数的用法，根据具体的数据拼接需求，可以灵活选择合适的参数来处理数据。pandas库提供了。
Pandas数据合并：concat与merge
这家伙很懒，什么都没有留下
01-15 1258
Pandas的concat和merge方法提供了强大的数据合并功能。concat方法适用于简单的拼接操作，如按行或按列合并。而merge方法则更类似于SQL中的JOIN操作，可以根据一个或多个键来合并两个DataFrame，实现复杂的关联关系。在实际应用中，我们可以根据具体需求选择合适的方法来合并数据。
pandas多种合并操作总结(merge,concat,append)
weixin_46539246的博客
09-03 1532
pandas 表格合并的常用方法总结
pandas dataframe的合并实现（append, merge, concat）
12-26
创建2个DataFrame： >>> df1 = pd.DataFrame(np.ones((4, 4))*1, columns=list('DCBA'), index=list('4321')) >>> df2 = pd.DataFrame(np.ones((4, 4))*2, columns=list('FEDC'), index=list('6543')) ...
Pandas合并DataFrame：Merge, Join, Concat, Append【Pandas入门教程6】
08-31
Pandas合并DataFrame_Merge,_Join,_Concat,_Append【Pandas入门教程6】
pandas merge 和 concat
悦光阴的博客
08-11 902
merge是按照列值或索引值进行连接，concat是按照轴进行拼接。 一，merge 数据库风格的连接是merge， DataFrame.merge(right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', ...
Pandas——concat（合并）
12-22
文章目录1.前言2.垂直合并（axis = 0）3.join(合并方式)4.join_axes5.append (添加数据) 1.前言 pandas处理多组数据的时候往往会要用到数据的合并处理,使用 concat是一种基本的合并方式.而且concat中有很多参数可以调整,合并成你想要的数据形式. 2.垂直合并（axis = 0） axis=0是预设值，因此未设定任何参数时，函数默认axis=0 import pandas as pd import numpy as np df1 = pd.DataFrame(np.ones((4,5))*6, columns = ['a','b','c','d
数据处理与统计分析——07-Pandas的concat连接、merge()合并、多表查询、内/外/自连接查询操作
m0_74893204的博客
12-02 2249
append()函数已过时, 它作用和concat()类似, 在新版的pandas中这个方法已经被删除了.merge更灵活，如果想依据行索引来合并DataFrame可以考虑使用join函数。如果名字不同, left_on 写左表字段, right_on 写右表字段.连接之后, 两张表中如果有相同名字的字段, 默认会加上后缀 默认值 _x,(3) DataFrame数据组合-join()merge()合并数据, 一对一。merge()合并数据, 一对多。df对象与df对象拼接。：查询左表所有数据，
pandas---数据合并（concat、append、merge）
weixin_43961909的博客
06-13 8684
不匹配级联指的是级联的维度的索引不一致。例如纵向级联时列索引不一致，横向级联时行索引不。按照行或列进行合并，axis=0为列索引，axis=1为行索引。内连接： 类似交集， 只显示共同的部分，只连接匹配的项。外连接：类似并集，显示所有数据，补NaN（默认模式）。对应索引没有值，会自动用NaN填充。
Pandas之数据合并（concat、merge）详解
零碎@流年絮语 的博客
08-08 1514
数据合并 #准备数据 import numpy as np import pandas as pd def make_df(cols,ind): '''生成一个简单的DataFrame数据''' data = {c: [str(c) + str(i) for i in ind] for c in cols} return pd.DataFrame(data,ind) #测试函数 df = make_df("ABC", range(5)) print(df) concat pd.c
pandas基础（三）（合并数据集concat、append、merge、join）
weixin_43336108的博客
11-21 349
on：用于连接的列索引名称，必须同时存在于左、右两个DataFrame中，默认是以两个DataFrame列名的交集作为连接键，若要实现多键连接，‘on’参数后传入多键列表即可。suffixes：字符串值组成的元组，用于指定当左右DataFrame存在相同列名时在列名后面附加的后缀名称，默认为(’_x’, ‘_y’)right_index：使用右侧DataFrame中的行索引作为连接键。right_on：右侧DataFrame中用于连接键的列名。left_on：左侧DataFrame中用于连接键的列名。
Python Pandas concat 和merge 总结 Part 1
How Sunyx Learn
04-20 495
最近在做Information Science的时候用到了concat和 merge，整理一下好了。 concat和mergeconcatmerge concat 当我用到concat的时候，我一般都是只想把两个dataframe连接起来，想法十分的简单，就是单纯的在连接，或者说拼接。官方网站上也有说可以去关联，但是出于习惯，我一般都直接用merge。 下面展示一些 内联代码片。 这是官方指南上的...
Pandas中的数据合并---merge与concat
wugou2014的博客
03-25 605
pandas中数据合并操作，主要是merge，其次是concat，append，join
Numpy学习笔记--08.Pandas合并 concat与merge
weixin_43124630的博客
03-14 418
都在代码中 import numpy as np import pandas as pd # merging two df by key/keys. (may be used in database) # simple example left = pd.DataFrame({'key':['K0', 'K1', 'K2', 'k3'], 'A':['...
pandas concat和merge
07-21
pandas中的concat和merge都是用于合并数据的函数，但是它们的使用场景和方法有所不同。 concat函数主要用于将多个数据集按照某个轴方向进行拼接，可以是行方向（axis=）或列方向（axis=1），并且可以指定拼接方式...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值