• Python根据乐谱生成音乐

    --*--

    （！）有更新版本：Python音乐制作-紧急修复版v1.2_Unconquerable&Llxy的博客-CSDN博客

    --*--

    外来库：Pysynth

    PySynth — A Music Synthesizer for Pythonhttps://mdoege.github.io/PySynth/#d

    文件资源：

    Python第三方库：Pysynth-Python文档类资源-CSDN下载学习资源，解压后使用。更多下载资源、学习资料请访问CSDN下载频道.https://download.csdn.net/download/html_finder/86441665

    音色有多种，取决于不同模块。这里不过多赘述。

    上 代 码 

    文件（1）melody.py

    1. # coding:utf-8
    2.  
    3. """
    5. ----------------------------------
    6. *    author: Unconquerable       *
    7. ----------------------------------
    9. a great tool to convert melody text to music.
    11. """
    12.  
    13. class sound(object):
    14.     high=4
    15.  
    16.     def __init__(self,high=4):
    17.         self.high=high
    18.     def __del__(self):
    19.         del self.high
    20.     def __str__(self):
    21.         return ""
    22.  
    23.     def upLoud(self,up=1):
    24.         self.high+=up
    25.     def downLoud(self,down=1):
    26.         self.high-=down
    27.     def absoluteLoud(self,abv=0):
    28.         self.high+=abv
    29.     absLoud=absoluteLoud
    30.     def resetLoud(self,value=4):
    31.         self.high=value
    32.     init=resetLoud
    33.  
    34.     @property
    35.     def toString(self):
    36.         return self.__str__()
    37.     real=toString
    38.  
    39.     def plus(self):
    40.         ...
    41.  
    42.     def plus_(self,num):
    43.         ...
    44.  
    45.     def nplus(self):
    46.         ...
    47.  
    48.  
    49. class C(sound):
    50.     high = 4
    51.     def __init__(self,high=4):
    52.         super().__init__(high=high)
    53.     def __str__(self):
    54.         return "c"+str(self.high)
    55.  
    56.     def plus(self):
    57.         return AddC(self.high)
    58.  
    59.     def plus_(self, num):
    60.         if num == 0: return self
    61.         if num < 0:
    62.             return self.nplus().plus_(num + 1)
    63.         if num > 0:
    64.             return self.plus().plus_(num - 1)
    65.  
    66.     def nplus(self):
    67.         return B(self.high-1)
    68.  
    69.  
    70.  
    71. class AddC(sound):
    72.     high = 4
    73.     def __init__(self,high):
    74.         super().__init__(high)
    75.     def __str__(self):
    76.         return "c#"+str(self.high)
    77.     def plus(self):
    78.         return D(self.high)
    79.  
    80.     def plus_(self, num):
    81.         if num == 0: return self
    82.         if num < 0:
    83.             return self.nplus().plus_(num + 1)
    84.         if num > 0:
    85.             return self.plus().plus_(num - 1)
    86.  
    87.     def nplus(self):
    88.         return C(self.high)
    89.  
    90. class D(sound):
    91.     high = 4
    92.     def __init__(self,high=4):
    93.         super().__init__(high=high)
    94.     def __str__(self):
    95.         return "d"+str(self.high)
    96.     def plus(self):
    97.         return AddD(self.high)
    98.  
    99.     def plus_(self, num):
    100.         if num == 0: return self
    101.         if num < 0:
    102.             return self.nplus().plus_(num + 1)
    103.         if num > 0:
    104.             return self.plus().plus_(num - 1)
    105.  
    106.     def nplus(self):
    107.         return AddC(self.high)
    108.  
    109. class AddD(sound):
    110.     high = 4
    111.     def __init__(self,high=4):
    112.         super().__init__(high=high)
    113.     def __str__(self):
    114.         return "d#"+str(self.high)
    115.     def plus(self):
    116.         return E(self.high)
    117.  
    118.     def plus_(self, num):
    119.         if num == 0: return self
    120.         if num < 0:
    121.             return self.nplus().plus_(num + 1)
    122.         if num > 0:
    123.             return self.plus().plus_(num - 1)
    124.  
    125.     def nplus(self):
    126.         return D(self.high)
    127.  
    128. class E(sound):
    129.     high = 4
    130.     def __init__(self,high=4):
    131.         super().__init__(high=high)
    132.     def __str__(self):
    133.         return "e"+str(self.high)
    134.     def plus(self):
    135.         return F(self.high)
    136.  
    137.     def plus_(self, num):
    138.         if num == 0: return self
    139.         if num < 0:
    140.             return self.nplus().plus_(num + 1)
    141.         if num > 0:
    142.             return self.plus().plus_(num - 1)
    143.  
    144.     def nplus(self):
    145.         return AddD(self.high)
    146.  
    147. class F(sound):
    148.     high = 4
    149.     def __init__(self,high=4):
    150.         super().__init__(high=high)
    151.     def __str__(self):
    152.         return "f"+str(self.high)
    153.     def plus(self):
    154.         return AddF(self.high)
    155.  
    156.     def plus_(self, num):
    157.         if num == 0: return self
    158.         if num < 0:
    159.             return self.nplus().plus_(num + 1)
    160.         if num > 0:
    161.             return self.plus().plus_(num - 1)
    162.  
    163.     def nplus(self):
    164.         return E(self.high)
    165.  
    166. class AddF(sound):
    167.     high = 4
    168.     def __init__(self,high=4):
    169.         super().__init__(high=high)
    170.     def __str__(self):
    171.         return "f#"+str(self.high)
    172.     def plus(self):
    173.         return G(self.high)
    174.  
    175.     def plus_(self, num):
    176.         if num == 0: return self
    177.         if num < 0:
    178.             return self.nplus().plus_(num + 1)
    179.         if num > 0:
    180.             return self.plus().plus_(num - 1)
    181.  
    182.     def nplus(self):
    183.         return F(self.high)
    184.  
    185. class G(sound):
    186.     high = 4
    187.     def __init__(self,high=4):
    188.         super().__init__(high=high)
    189.     def __str__(self):
    190.         return "g"+str(self.high)
    191.     def plus(self):
    192.         return AddG(self.high)
    193.  
    194.     def plus_(self, num):
    195.         if num == 0: return self
    196.         if num < 0:
    197.             return self.nplus().plus_(num + 1)
    198.         if num > 0:
    199.             return self.plus().plus_(num - 1)
    200.  
    201.     def nplus(self):
    202.         return AddF(self.high)
    203.  
    204. class AddG(sound):
    205.     high = 4
    206.     def __init__(self,high=4):
    207.         super().__init__(high=high)
    208.     def __str__(self):
    209.         return "g#"+str(self.high)
    210.     def plus(self):
    211.         return A(self.high)
    212.  
    213.     def plus_(self, num):
    214.         if num == 0: return self
    215.         if num < 0:
    216.             return self.nplus().plus_(num + 1)
    217.         if num > 0:
    218.             return self.plus().plus_(num - 1)
    219.  
    220.     def nplus(self):
    221.         return G(self.high)
    222.  
    223. class A(sound):
    224.     high = 4
    225.     def __init__(self,high=4):
    226.         super().__init__(high=high)
    227.     def __str__(self):
    228.         return "a"+str(self.high)
    229.     def plus(self):
    230.         return AddA(self.high)
    231.  
    232.     def plus_(self, num):
    233.         if num == 0: return self
    234.         if num < 0:
    235.             return self.nplus().plus_(num + 1)
    236.         if num > 0:
    237.             return self.plus().plus_(num - 1)
    238.  
    239.     def nplus(self):
    240.         return AddG(self.high)
    241.  
    242. class AddA(sound):
    243.     high = 4
    244.     def __init__(self,high=4):
    245.         super().__init__(high=high)
    246.     def __str__(self):
    247.         return "a#"+str(self.high)
    248.     def plus(self):
    249.         return B(self.high)
    250.  
    251.     def plus_(self, num):
    252.         if num == 0: return self
    253.         if num < 0:
    254.             return self.nplus().plus_(num + 1)
    255.         if num > 0:
    256.             return self.plus().plus_(num - 1)
    257.  
    258.     def nplus(self):
    259.         return A(self.high)
    260.  
    261. class B(sound):
    262.     high = 4
    263.     def __init__(self,high=4):
    264.         super().__init__(high=high)
    265.     def __str__(self):
    266.         return "b"+str(self.high)
    267.     def plus(self):
    268.         return C(self.high+1)
    269.  
    270.     def plus_(self, num):
    271.         if num == 0: return self
    272.         if num < 0:
    273.             return self.nplus().plus_(num + 1)
    274.         if num > 0:
    275.             return self.plus().plus_(num - 1)
    276.  
    277.     def nplus(self):
    278.         return AddA(self.high)
    279.  
    280. class NULL(sound):
    281.     def __str__(self):
    282.         return "r"
    283. class time(object):
    284.     real = 0
    285.     def __init__(self,time=4):
    286.         self.real= 4/time
    287.  
    288. class note(object):
    289.     sound_ = sound()
    290.     time_ = time()
    291.  
    292.     def __init__(self,sd,t):
    293.         self.soundSet(sd)
    294.         self.timeSet(t)
    295.  
    296.     def soundSet(self,sd):
    297.         if isinstance(sd,str):
    298.             nd=sd[:-1].upper()
    299.             dct={"C":C,"C#":AddC,"D":D,"D#":AddD,"E":E,"F":F,
    300.                  "F#":AddF,"G":G,"G#":AddG,"A":A,"A#":AddA,"B":B,"R":NULL}
    301.             self.sound_=dct[nd](int(sd[-1]))
    302.         if isinstance(sd,sound):
    303.             self.sound_=sd
    304.         if isinstance(sd,tuple):
    305.             nd = sd[:-1].upper()
    306.             dct = {"C": C, "C#": AddC, "D": D, "D#": AddD, "E": E, "F": F,
    307.                    "F#": AddF, "G": G, "G#": AddG, "A": A, "A#": AddA, "B": B, "R": NULL}
    308.             self.sound_ = dct[nd](int(sd[-1]))
    309.  
    310.     def timeSet(self,t):
    311.         if isinstance(t,(int,float)):
    312.             self.time_=time(t)
    313.         if isinstance(t,time):
    314.             self.time_=t
    315.  
    316.     @property
    317.     def out(self):
    318.         return self.sound_.toString,self.time_.real
    319. class wav:
    320.     melody=C(4)
    321.     sound=[]
    322.     staticTime=1
    323.     def __init__(self,text=None,split=' '):
    324.         if text:
    325.             self.load(text=text,split=split)
    326.     def __del__(self):
    327.         pass
    328.  
    329.     @property
    330.     def getMelody(self):
    331.         return self.melody
    332.  
    333.     @property
    334.     def getSound(self):
    335.         return self.sound
    336.  
    337.     @property
    338.     def getTime(self):
    339.         return self.staticTime
    340.  
    341.     def setTime(self,time):
    342.         self.staticTime=time
    343.  
    344.     def setMelody(self,melody):
    345.         self.melody=melody
    346.     def loadOneNote(self,n):
    347.         if isinstance(n,note):
    348.             self.sound.append(n.out)
    349.         if isinstance(n,str):
    350.             n=n.strip()
    351.             if n[0]=="0":
    352.                 t=self.staticTime
    353.                 for i in n[1:]:
    354.                     if i == "-":  # 延音符号
    355.                         t += self.staticTime
    356.                     if i == "_":  # 半音符号
    357.                         t /= 2
    358.                     # (!)不要让延音符号和半音符号同时出现
    359.                     if i == ".":  # 附点音符
    360.                         t += t / 2
    361.  
    362.                 self.sound.append(("r",4/t))
    363.                 return
    364.             #简谱
    365.             t=self.staticTime
    366.             dct={
    367.                 1:0,
    368.                 2:2,
    369.                 3:4,
    370.                 4:5,
    371.                 5:7,
    372.                 6:9,
    373.                 7:11
    374.             }
    375.             l=self.melody.plus_(dct[int(n[0])])
    376.             for i in n[1:]:
    377.                 if i=="#":#升音符号
    378.                     l.plus()
    379.                 if i=="&":#降音符号
    380.                     l.nplus()
    381.                 if i=="-":#延音符号
    382.                     t+=self.staticTime
    383.                 if i=="_":#半音符号
    384.                     t/=2
    385.                 # (!)不要让延音符号和半音符号同时出现
    386.                 if i==".":#附点音符
    387.                     t+=t/2
    388.                 if i=="+":#升音
    389.                     l.upLoud(1)
    390.                 if i=="!":#降音
    391.                     l.downLoud(1)
    392.  
    393.             mixed=note(l,t).out
    394.             self.sound.append(mixed)
    395.     def load(self,text,split=''):
    396.         if split!='':
    397.             for i in text.split(split):
    398.                 self.loadOneNote(i)
    399.         else:
    400.             tp=""
    401.             for i in text:
    402.                 if i.isnumeric():
    403.                     if tp.strip() != "":
    404.                         self.loadOneNote(tp.strip())
    405.                     tp=""
    406.                 tp+=i
    407.  
    408.     def make_wav(self,module="pysynth",bpm=120,transpose=0,pause=.05,boost=1.1,
    409.                  repeat=0,fn="out.wav", silent=False):
    410.         __import__(module.lower()).make_wav(song=self.sound,bpm=bpm,transpose=transpose,
    411.                                     pause=pause,boost=boost,repeat=repeat,
    412.                                     fn=fn, silent=silent)
    413.  
    414.

    文件：2（可有可无，可以规定调用的规范）melody.pyi

    1. # coding:utf-8
    2.  
    3. """
    5. ----------------------------------
    6. *    author: Unconquerable       *
    7. ----------------------------------
    9. a great tool to convert melody text to music.
    11. """
    12.  
    13.  
    14. from typing import Union
    15.  
    16. class sound(object):
    17.     high:int
    18.  
    19.     def __init__(self,high:int=4): ...
    20.     def __del__(self): ...
    21.     def __str__(self) -> str: ...
    22.  
    23.     def upLoud(self,up:int) -> None: ...
    24.     def downLoud(self,down:int) -> None: ...
    25.     def absoluteLoud(self,abv:int) -> None: ...
    26.     absLoud=absoluteLoud
    27.     def resetLoud(self,value:int) -> None: ...
    28.     init=resetLoud
    29.     @property
    30.     def toString(self) -> str : ...
    31.     real=toString
    32.  
    33.     def plus(self) -> sound : ...
    34.     def plus_(self,num:int) -> sound : ...
    35.     def nplus(self) -> sound: ...
    36.  
    37. class C(sound):
    38.     high:int
    39.  
    40.     def __init__(self,high:int=4):
    41.         super(C,self).__init__(high=high)
    42.         ...
    43.     def __str__(self) -> str: ...
    44.  
    45.     def plus(self) -> sound : ...
    46.     def plus_(self,num:int) -> sound : ...
    47.     def nplus(self) -> sound: ...
    48.  
    49. class AddC(sound):
    50.     high:int
    51.  
    52.     def __init__(self,high:int=4):
    53.         super(AddC,self).__init__(high=high)
    54.         ...
    55.     def __str__(self) -> str: ...
    56.  
    57.     def plus(self) -> sound : ...
    58.     def plus_(self,num:int) -> sound : ...
    59.     def nplus(self) -> sound: ...
    60.  
    61. class D(sound):
    62.     high:int
    63.  
    64.     def __init__(self,high:int=4):
    65.         super(D,self).__init__(high=high)
    66.         ...
    67.     def __str__(self) -> str: ...
    68.  
    69.     def plus(self) -> sound : ...
    70.     def plus_(self,num:int) -> sound : ...
    71.     def nplus(self) -> sound: ...
    72.  
    73. class AddD(sound):
    74.     high:int
    75.  
    76.     def __init__(self,high:int=4):
    77.         super(AddD,self).__init__(high=high)
    78.         ...
    79.     def __str__(self) -> str: ...
    80.  
    81.     def plus(self) -> sound : ...
    82.     def plus_(self,num:int) -> sound : ...
    83.     def nplus(self) -> sound: ...
    84.  
    85. class E(sound):
    86.     high:int
    87.  
    88.     def __init__(self,high:int=4):
    89.         super(E,self).__init__(high=high)
    90.         ...
    91.     def __str__(self) -> str: ...
    92.  
    93.     def plus(self) -> sound : ...
    94.     def plus_(self,num:int) -> sound : ...
    95.     def nplus(self) -> sound: ...
    96.  
    97. class F(sound):
    98.     high:int
    99.  
    100.     def __init__(self,high:int=4):
    101.         super(F,self).__init__(high=high)
    102.         ...
    103.     def __str__(self) -> str: ...
    104.  
    105.     def plus(self) -> sound : ...
    106.     def plus_(self,num:int) -> sound : ...
    107.     def nplus(self) -> sound: ...
    108.  
    109. class AddF(sound):
    110.     high:int
    111.  
    112.     def __init__(self,high:int=4):
    113.         super(AddF,self).__init__(high=high)
    114.         ...
    115.     def __str__(self) -> str: ...
    116.  
    117.     def plus(self) -> sound : ...
    118.     def plus_(self,num:int) -> sound : ...
    119.     def nplus(self) -> sound: ...
    120.  
    121. class G(sound):
    122.     high:int
    123.  
    124.     def __init__(self,high:int=4):
    125.         super(G,self).__init__(high=high)
    126.         ...
    127.     def __str__(self) -> str: ...
    128.  
    129.     def plus(self) -> sound : ...
    130.     def plus_(self,num:int) -> sound : ...
    131.     def nplus(self) -> sound: ...
    132.  
    133. class AddG(sound):
    134.     high:int
    135.  
    136.     def __init__(self,high:int=4):
    137.         super(AddG,self).__init__(high=high)
    138.         ...
    139.     def __str__(self) -> str: ...
    140.  
    141.     def plus(self) -> sound : ...
    142.     def plus_(self,num:int) -> sound : ...
    143.     def nplus(self) -> sound: ...
    144.  
    145. class A(sound):
    146.     high:int
    147.  
    148.     def __init__(self,high:int=4):
    149.         super(A,self).__init__(high=high)
    150.         ...
    151.     def __str__(self) -> str: ...
    152.  
    153.     def plus(self) -> sound : ...
    154.     def plus_(self,num:int) -> sound : ...
    155.     def nplus(self) -> sound: ...
    156.  
    157. class AddA(sound):
    158.     high:int
    159.  
    160.     def __init__(self,high:int=4):
    161.         super(AddA,self).__init__(high=high)
    162.         ...
    163.     def __str__(self) -> str: ...
    164.  
    165.     def plus(self) -> sound : ...
    166.     def plus_(self,num:int) -> sound : ...
    167.     def nplus(self) -> sound: ...
    168.  
    169. class B(sound):
    170.     high:int
    171.  
    172.     def __init__(self,high:int=4):
    173.         super(B,self).__init__(high=high)
    174.         ...
    175.     def __str__(self) -> str: ...
    176.  
    177.     def plus(self) -> sound : ...
    178.     def plus_(self,num:int) -> sound : ...
    179.     def nplus(self) -> sound: ...
    180.  
    181. class NULL(sound):
    182.     def __str__(self) -> str: ...
    183.  
    184. class time(object):
    185.     real : int
    186.     def __init__(self,time:int=4): ...
    187.  
    188. class note(object):
    189.     sound_ : sound
    190.     time_ : time
    191.  
    192.     def __init__(self,sd:Union[sound,str,tuple],t:Union[time,int,float]): ...
    193.  
    194.     def soundSet(self,sd:Union[sound,str,tuple]) -> None: ...
    195.  
    196.     def timeSet(self,t:Union[time,int,float]) -> None: ...
    197.  
    198.     @property
    199.     def out(self) -> tuple[str,int]: ...
    200.  
    201. class wav:
    202.     melody:sound
    203.     sound:list
    204.     staticTime:Union[int,float]
    205.  
    206.     def __init__(self,text:Union[str,None]=None,split:str=' ') : ...
    207.     def __del__(self) :  ...
    208.  
    209.     @property
    210.     def getMelody(self) -> str: ...
    211.  
    212.     @property
    213.     def getSound(self) -> list: ...
    214.  
    215.     @property
    216.     def getTime(self) -> Union[int,float]:...
    217.  
    218.     def setTime(self,time:Union[int,float]) -> None: ...
    219.     def setMelody(self,melody:sound) -> None: ...
    220.     def loadOneNote(self,n:str) -> None: ...
    221.     def load(self,text:str,split:str=' ') -> None: ...
    222.  
    223.     def make_wav(self,module:str="pysynth",bpm:Union[int,float]=120,transpose:int=0,pause:float=.05,
    224.                  boost:float=1.1,repeat:int=0,fn:str="out.wav", silent:bool=False) -> None: ...

    调用（1.py，同目录，父目录名称为MELODY。）：

    第三行import语句根据情况自行更改。

    open里面的文件名自定。

    1. # coding=utf-8
    2.  
    3. from MELODY.melody import *
    4.  
    5.  
    6. a=wav()
    7.  
    8. text=open(r".\1.txt").read()
    9. text=text.split("-*-")
    10.  
    11. a.setMelody(note(text[1].strip(),1).sound_)
    12. a.setTime(int(text[2].strip()))
    13.  
    14. a.load(
    15.     str(text[3]).strip()
    16. )
    17. res=text[0].strip().split("|")
    18.  
    19. a.make_wav(module=res[0],bpm=eval(res[1]),repeat=eval(res[2]),fn=res[3])

    1.txt：

    格式为：

    1. 字符串，引用模块名|整数|整数|存储文件名
    2. -*-
    3. 调式，例如：1=C则填写c，1=降B则填写a#（即升a）
    4. -*-
    5. 节拍。例如，默认为每个音四分音符，即1 。
    6. -*-
    7. （乐谱部分）

    注意：上面的部分基本不用更改。接下来是我写的一个模板。

    1. pysynth|120|0|file.wav
    2. -*-
    3. c
    4. -*-
    5. 1
    6. -*-

    接下来要进行介绍。

    第一行，以"|"分割。

    "pysynth"表示使用默认音色。音色列表见下：

    PySynth_A

    这种加法单声道合成器非常简单，听起来有点像长笛或风琴，结合了钢琴般的音符音量衰减。PySynth A 只需要 Python 本身。它应该在所有 Python 支持的平台上运行，例如 Windows、Unix 和 Mac。

    PySynth_B

    一个加法合成器模块，它试图用更多的谐波创建更像钢琴的声音。这个版本是复调的，因为它不会在下一个音符响起时切断前一个音符。

    PySynth_C

    PySynth C 是一种基于减法合成的简单弓弦音色。它使用锯齿波振荡器和低通滤波器，类似于 1970 年代的模拟合成器（或amsynth中的弦乐声音，或来自MOS Technology SID的声音）。与 PySynth A 一样，它只需要 Python 本身即可运行。

    PySynth_D

    PySynth D 使用与 PySynth C 类似的减法合成，但它基于方波。这种合成器主音类型的声音让人联想到木管乐器。方波也用于 1970 年代/1980 年代的计算机声音芯片，例如General Instrument AY-3-8910或Atari POKEY。只需要 Python 本身。

    PySynth_E

    该模块基于 PySynth B，基于相位调制创建简单的电子钢琴声音，这是进行 FM 合成的常用方法，例如在 1980 年代 Yamaha 合成器上。这种声音当然是受到Yamaha DX7上的 Rhodes 钢琴的启发。

    PySynth_P

    PySynth P 使用与 PySynth C 和 D 类似的减法合成，但基于具有指数体积包络的白噪声。它会产生未经调音的打击乐声音。这种类型的声音在 1980 年代通常用于打击乐和游戏音效。只需要 Python 本身。

    PySynth_S

    该模块使用Karplus-Strong 算法（想想吉他或大键琴）模拟单个弹拨。由于这种合成的性质，特别是较高频率的音符可能会与 PySynth S 稍微不协调，这与谐波精确的其他变体相反。这可以通过更高的采样率来解决，但这也会使其对 Python 来说有点慢。

    PySynth_beeper

    这个贡献的合成器属于nokiacomposer2wav.py并且应该重新创建老式诺基亚功能手机的铃声。

    PySynth_samp

    此合成器使用 48 kHz、24 位Salamander 钢琴样本。请在第 50 行设置 Salamander WAV 的路径（包括尾部斜杠）。

    第二个值120表示了一分钟内演奏多少个四分音符。

    第三个值是重复次数，默认为0，即不重复。

    第四个值是文件存储路径。

    第三行，一个值，表示调式。可选的有：

    c c# d d# e f f# g g# a a# b

    第五行，一个值，表示一个数字算作几个四分音符。如果没有特殊需要，填1就可以

    乐谱部分。

    简谱表示

    升音用#

    降音用&

    半音用_

    延音用-

    附点用.

    高八度用+

    降八度用!

    （全部用英文符）

    接下来会逐渐（断断续续）发布一些相关的音乐材料（txt文件，用刚才的1.py解释一下就可以导出为wav文件了）

    OK再~见~~~

  • 相关阅读:
    Python Web 框架：你需要知道的一切
    将本地jar包手动添加到Maven仓库依赖处理
    9.DesignForManufacture\CreateArtwork...
    React SSR - 写个 Demo 一学就会
    亿某通电子文档安全管理系统任意文件上传漏洞 CNVD-2022-43886
    C++11右值引用的价值体现
    输入输出、文件读写、数据类型
    PWN入门（2）栈溢出基础
    用Unity同时开发【微信小游戏】【安卓】【IOS】游戏#6.2 WebSocket通信
    设计模式的六大原则
  • 原文地址：https://blog.csdn.net/html_finder/article/details/126499254