经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » Python » 查看文章
21.1 Python 使用PEfile分析PE文件
来源：cnblogs　　作者：lyshark　　时间：2023/10/20 8:45:25　　对本文有异议

PeFile模块是Python中一个强大的便携式第三方PE格式分析工具，用于解析和处理Windows可执行文件。该模块提供了一系列的API接口，使得用户可以通过Python脚本来读取和分析PE文件的结构，包括文件头、节表、导入表、导出表、资源表、重定位表等等。此外，PEfile模块还可以帮助用户进行一些恶意代码分析，比如提取样本中的字符串、获取函数列表、重构导入表、反混淆等等。PEfile模块是Python中处理PE文件的重要工具之一，广泛应用于二进制分析、安全研究和软件逆向工程等领域。

由于该模块为第三方模块，在使用之前读者需要在命令行下执行pip install pefile命令安装第三方库，当安装成功后即可正常使用，如下所示则是该模块的基本使用方法，读者可自行学习理解。

21.1.1 打开并加载PE文件

如下这段代码封装并实现了OpenPeFile函数，可用于打开一个PE文件，在其内部首先判断了可执行文件是否被压缩如果被压缩则会通过zipfile模块将压缩包读入内存并调用C2BIP3函数将数据集转换为2字节，接着再执行pefile.PE()函数，该函数可用于将可执行文件载入，至此读者可在主函数内通过pe.dump_dict()的方式输出该PE文件的所有参数，由于输出的是字典，读者可以使用字典与列表的方式灵活的提取出该程序的所有参数信息。

  1. import sys
  2. import zipfile
  3. import pefile
  5. # 如果是Python3则转换为2字节
  6. def C2BIP3(string):
  7.     if sys.version_info[0] > 2:
  8.         return bytes([ord(x) for x in string])
  9.     else:
  10.         return string
  12. # 打开文件
  13. def OpenPeFile(filename):
  15.     # 判断是否是ZIP压缩包
  16.     if filename.lower().endswith('.zip'):
  17.         try:
  18.             oZipfile = zipfile.ZipFile(filename, 'r')
  19.             file = oZipfile.open(oZipfile.infolist()[0], 'r', C2BIP3('infected'))
  20.         except Exception:
  21.             print(sys.exc_info()[1])
  22.             sys.exit()
  23.         oPE = pefile.PE(data=file.read())
  24.         file.close()
  25.         oZipfile.close()
  27.     # 如果是空则
  28.     elif filename == '':
  29.         oPE = False
  30.         return oPE
  31.     # 否则直接打开文件
  32.     else:
  33.         oPE = pefile.PE(filename)
  34.     return oPE
  36. if __name__ == "__main__":
  37.     pe = OpenPeFile("d://lyshark.exe")
  38.     print(pe.FILE_HEADER.dump())
  39.     print(pe.dump_dict())

21.1.2 解析PE头部数据

如下代码实现了解析PE结构中头部基本数据，在GetHeader函数内，我们首先通过pe.FILE_HEADER.Machine成员判断当前读入的文件的位数信息，通过pe.FILE_HEADER.Characteristics可判断PE文件的类型，通常为EXE可执行文件或DLL动态链接库文件，通过AddressOfEntryPoint加上ImageBase则可获取到程序的实际装载地址，压缩数据的计算可通过hashlib模块对PE文件字节数据进行计算摘要获取，最后是附加数据，通过get_overlay_data_start_offset则可获取到，并依次循环即可输出所有附加数据。

  1. import hashlib
  2. import pefile
  4. # 计算得到数据长度,自动使用推荐大小
  5. def NumberOfBytesHumanRepresentation(value):
  6.     if value <= 1024:
  7.         return '%s bytes' % value
  8.     elif value < 1024 * 1024:
  9.         return '%.1f KB' % (float(value) / 1024.0)
  10.     elif value < 1024 * 1024 * 1024:
  11.         return '%.1f MB' % (float(value) / 1024.0 / 1024.0)
  12.     else:
  13.         return '%.1f GB' % (float(value) / 1024.0 / 1024.0 / 1024.0)
  15. # 获取PE头部基本信息
  16. def GetHeader(pe):
  17.     raw = pe.write()
  19.     # 扫描基本信息
  20.     print("-" * 50)
  21.     print("程序基本信息")
  22.     print("-" * 50)
  23.     if (hex(pe.FILE_HEADER.Machine) == "0x14c"):
  24.         print("程序位数: {}".format("x86"))
  25.     if (hex(pe.FILE_HEADER.Machine) == "0x8664"):
  26.         print("程序位数: {}".format("x64"))
  28.     if (hex(pe.FILE_HEADER.Characteristics) == "0x102"):
  29.         print("程序类型: Executable")
  30.     elif (hex(pe.FILE_HEADER.Characteristics) == "0x2102"):
  31.         print("程序类型: Dynamic link library")
  33.     if pe.OPTIONAL_HEADER.AddressOfEntryPoint:
  34.         oep = pe.OPTIONAL_HEADER.AddressOfEntryPoint + pe.OPTIONAL_HEADER.ImageBase
  35.         print("实际入口: {}".format(hex(oep)))
  37.     print("映像基址: {}".format(hex(pe.OPTIONAL_HEADER.ImageBase)))
  38.     print("虚拟入口: {}".format(hex(pe.OPTIONAL_HEADER.AddressOfEntryPoint)))
  39.     print("映像大小: {}".format(hex(pe.OPTIONAL_HEADER.SizeOfImage)))
  40.     print("区段对齐: {}".format(hex(pe.OPTIONAL_HEADER.SectionAlignment)))
  41.     print("文件对齐: {}".format(hex(pe.OPTIONAL_HEADER.FileAlignment)))
  42.     print("区块数量: {}".format(int(pe.FILE_HEADER.NumberOfSections + 1)))
  43.     print('熵值比例: %f (Min=0.0, Max=8.0)' % pe.sections[0].entropy_H(raw))
  45.     # 计算压缩数据
  46.     print("-" * 50)
  47.     print("计算压缩数据")
  48.     print("-" * 50)
  49.     print('MD5     : %s' % hashlib.md5(raw).hexdigest())
  50.     print('SHA-1   : %s' % hashlib.sha1(raw).hexdigest())
  51.     print('SHA-256 : %s' % hashlib.sha256(raw).hexdigest())
  52.     print('SHA-512 : %s' % hashlib.sha512(raw).hexdigest())
  54.     # 扫描文件末尾是否存在附加数据
  55.     print("-" * 50)
  56.     print("扫描附加数据")
  57.     print("-" * 50)
  58.     overlayOffset = pe.get_overlay_data_start_offset()
  59.     if overlayOffset != None:
  60.         print("起始文件位置: 0x%08x"%overlayOffset)
  61.         overlaySize = len(raw[overlayOffset:])
  62.         print("长度: 0x%08x %s %.2f%%"%(overlaySize, NumberOfBytesHumanRepresentation(overlaySize), float(overlaySize) / float(len(raw)) * 100.0))
  63.         print("MD5: %s" %hashlib.md5(raw[overlayOffset:]).hexdigest())
  64.         print("SHA-256: %s" %hashlib.sha256(raw[overlayOffset:]).hexdigest())
  66. if __name__ == "__main__":
  67.     pe = pefile.PE("d://lyshark.exe")
  68.     GetHeader(pe)

21.1.3 解析节表数据

运用PEFile模块解析节表也很容易，如下代码中分别实现了两个功能函数，函数ScanSection()用于输出当前文件的所有节表数据，其中通过pe.FILE_HEADER.NumberOfSections得到节表数量，并通过循环的方式依次解析pe.sections中的每一个节中元素，函数CheckSection()则可用于计算PE文件节大小以及节MD5值，完整代码如下所示；

  1. import hashlib
  2. import pefile
  4. # 计算得到数据长度,自动使用推荐大小
  5. def NumberOfBytesHumanRepresentation(value):
  6.     if value <= 1024:
  7.         return '%s bytes' % value
  8.     elif value < 1024 * 1024:
  9.         return '%.1f KB' % (float(value) / 1024.0)
  10.     elif value < 1024 * 1024 * 1024:
  11.         return '%.1f MB' % (float(value) / 1024.0 / 1024.0)
  12.     else:
  13.         return '%.1f GB' % (float(value) / 1024.0 / 1024.0 / 1024.0)
  15. # 输出所有的节
  16. def ScanSection(pe):
  17.     print("-" * 100)
  18.     print("{:10s}{:10s}{:10s}{:10s}{:10s}{:10s}{:10s}{:10s}".
  19.           format("序号","节区名称","虚拟偏移","虚拟大小","实际偏移","实际大小","节区属性","熵值"))
  20.     print("-" * 100)
  21.     section_count = int(pe.FILE_HEADER.NumberOfSections + 1)
  23.     for count,item in zip(range(1,section_count),pe.sections):
  24.         print("%d\t\t\t%-10s\t0x%.8X\t0x%.8X\t0x%.8X\t0x%.8X\t0x%.8X\t%f"
  25.               %(count,(item.Name).decode("utf-8"),item.VirtualAddress,item.Misc_VirtualSize,item.PointerToRawData,item.SizeOfRawData,item.Characteristics,item.get_entropy()))
  26.     print("-" * 100)
  28. # 计算所有节的MD5
  29. def CheckSection(pe):
  30.     print("-" * 100)
  31.     print("序号\t\t节名称\t\t文件偏移\t\t大小\t\tMD5\t\t\t\t\t\t\t\t\t\t节大小")
  32.     print("-" * 100)
  34.     # 读取PE文件到内存
  35.     image_data = pe.get_memory_mapped_image()
  37.     section_count = int(pe.FILE_HEADER.NumberOfSections + 1)
  38.     for count,item in zip(range(1,section_count),pe.sections):
  40.         section_data = image_data[item.PointerToRawData: item.PointerToRawData + item.SizeOfRawData - 1]
  41.         data_size = NumberOfBytesHumanRepresentation(len(section_data))
  42.         hash_value = hashlib.md5(section_data).hexdigest()
  43.         print("{}\t{:10s}\t{:10X}\t{:10X}\t{:30s}\t{}".format(count,(item.Name).decode("utf-8"),item.PointerToRawData,item.SizeOfRawData,hash_value,data_size))
  44.     print("-" * 100)
  46. if __name__ == "__main__":
  47.     pe = pefile.PE("d://lyshark.exe")
  48.     ScanSection(pe)
  49.     CheckSection(pe)

21.1.4 节区RVA与FOA互转

此处计算节偏移地址，相信读者能理解，在之前的文章中我们详细的介绍了PE文件如何进行RVA与FOA以及VA之间的转换的，如果是在平时的恶意代码分析中需要快速实现转换那么使用Python将是一个不错的选择，如下代码中RVAToFOA可将一个RVA相对地址转换为FOA文件偏移，FOAToRVA则可实现将一个FOA文件偏移转换为RVA先对地址，当然PeFile模块内也提供了get_rva_from_offset实现从FOA转RVA，get_offset_from_rva则是从RVA到FOA，读者可自行选择不同的转换方式。

  1. import pefile
  3. # 将RVA转换为FOA的函数
  4. def RVAToFOA(pe,rva):
  5.     for item in pe.sections:
  6.         Section_Start = item.VirtualAddress
  7.         Section_Ends = item.VirtualAddress + item.SizeOfRawData
  8.         if rva >= Section_Start and rva < Section_Ends:
  9.             return rva - item.VirtualAddress + item.PointerToRawData
  10.     return -1
  12. # 将FOA文件偏移转换为RVA相对地址
  13. def FOAToRVA(pe,foa):
  14.     ImageBase = pe.OPTIONAL_HEADER.ImageBase
  15.     NumberOfSectionsCount = pe.FILE_HEADER.NumberOfSections
  17.     for index in range(0,NumberOfSectionsCount):
  18.         PointerRawStart = pe.sections[index].PointerToRawData
  19.         PointerRawEnds = pe.sections[index].PointerToRawData + pe.sections[index].SizeOfRawData
  21.         if foa >= PointerRawStart and foa <= PointerRawEnds:
  22.             rva = pe.sections[index].VirtualAddress + (foa - pe.sections[index].PointerToRawData)
  23.             return rva
  24.     return -1
  26. # 内部功能实现FOA->RVA互转
  27. def inside(pe):
  28.     # 从FOA获取RVA 传入十进制
  29.     rva = pe.get_rva_from_offset(3952)
  30.     print("对应内存RVA: {}".format(hex(rva)))
  32.     # 从RVA获取FOA 传入十进制
  33.     foa = pe.get_offset_from_rva(rva)
  34.     print("对应文件FOA: {}".format(foa))
  36. if __name__ == "__main__":
  37.     pe = pefile.PE("d://lyshark.exe")
  38.     ref = RVAToFOA(pe,4128)
  39.     print("RVA转FOA => 输出十进制: {}".format(ref))
  41.     ref = FOAToRVA(pe,1056)
  42.     print("FOA转RVA => 输出十进制: {}".format(ref))

21.1.5 解析数据为Hex格式

如下代码片段实现了对PE文件的各种十六进制操作功能，封装cDump()类，该类内由多个类函数可以使用，其中HexDump()可用于将读入的PE文件以16进制方式输出，HexAsciiDump()则可用于输出十六进制以及所对应的ASCII格式，GetSectionHex()用于找到PE文件的.text节，并将此节内的数据读入到内存中，这段代码可以很好的实现对PE文件的十六进制输出与解析，读者可在实际开发中使用。

  1. import pefile
  2. from io import StringIO
  3. import sys
  4. import re
  6. dumplinelength = 16
  8. def CIC(expression):
  9.     if callable(expression):
  10.         return expression()
  11.     else:
  12.         return expression
  14. def IFF(expression, valueTrue, valueFalse):
  15.     if expression:
  16.         return CIC(valueTrue)
  17.     else:
  18.         return CIC(valueFalse)
  20. class cDump():
  21.     def __init__(self, data, prefix='', offset=0, dumplinelength=16):
  22.         self.data = data
  23.         self.prefix = prefix
  24.         self.offset = offset
  25.         self.dumplinelength = dumplinelength
  27.     # 输出指定位置的十六进制格式
  28.     def HexDump(self):
  29.         oDumpStream = self.cDumpStream(self.prefix)
  30.         hexDump = ''
  31.         for i, b in enumerate(self.data):
  32.             if i % self.dumplinelength == 0 and hexDump != '':
  33.                 oDumpStream.Addline(hexDump)
  34.                 hexDump = ''
  35.             hexDump += IFF(hexDump == '', '', ' ') + '%02X' % self.C2IIP2(b)
  36.         oDumpStream.Addline(hexDump)
  37.         return oDumpStream.Content()
  39.     def CombineHexAscii(self, hexDump, asciiDump):
  40.         if hexDump == '':
  41.             return ''
  42.         countSpaces = 3 * (self.dumplinelength - len(asciiDump))
  43.         if len(asciiDump) <= self.dumplinelength / 2:
  44.             countSpaces += 1
  45.         return hexDump + '  ' + (' ' * countSpaces) + asciiDump
  47.     # 输出指定位置的十六进制格式以及ASCII字符串
  48.     def HexAsciiDump(self):
  49.         oDumpStream = self.cDumpStream(self.prefix)
  50.         hexDump = ''
  51.         asciiDump = ''
  52.         for i, b in enumerate(self.data):
  53.             b = self.C2IIP2(b)
  54.             if i % self.dumplinelength == 0:
  55.                 if hexDump != '':
  56.                     oDumpStream.Addline(self.CombineHexAscii(hexDump, asciiDump))
  57.                 hexDump = '%08X:' % (i + self.offset)
  58.                 asciiDump = ''
  59.             if i % self.dumplinelength == self.dumplinelength / 2:
  60.                 hexDump += ' '
  61.             hexDump += ' %02X' % b
  62.             asciiDump += IFF(b >= 32 and b <= 128, chr(b), '.')
  63.         oDumpStream.Addline(self.CombineHexAscii(hexDump, asciiDump))
  64.         return oDumpStream.Content()
  66.     class cDumpStream():
  67.         def __init__(self, prefix=''):
  68.             self.oStringIO = StringIO()
  69.             self.prefix = prefix
  71.         def Addline(self, line):
  72.             if line != '':
  73.                 self.oStringIO.write(self.prefix + line + '\n')
  75.         def Content(self):
  76.             return self.oStringIO.getvalue()
  78.     @staticmethod
  79.     def C2IIP2(data):
  80.         if sys.version_info[0] > 2:
  81.             return data
  82.         else:
  83.             return ord(data)
  85. # 只输出十六进制数据
  86. def HexDump(data):
  87.     return cDump(data, dumplinelength=dumplinelength).HexDump()
  89. # 输出十六进制与ASCII字符串
  90. def HexAsciiDump(data):
  91.     return cDump(data, dumplinelength=dumplinelength).HexAsciiDump()
  93. # 找到指定节并读取hex数据
  94. def GetSectionHex(pe):
  95.     ImageBase = pe.OPTIONAL_HEADER.ImageBase
  96.     for item in pe.sections:
  97.         # 判断是否是.text节
  98.         if str(item.Name.decode('UTF-8').strip(b'\x00'.decode())) == ".text":
  99.             # print("虚拟地址: 0x%.8X 虚拟大小: 0x%.8X" %(item.VirtualAddress,item.Misc_VirtualSize))
  100.             VirtualAddress = item.VirtualAddress
  101.             VirtualSize = item.Misc_VirtualSize
  102.             ActualOffset = item.PointerToRawData
  104.             StartVA = hex(ImageBase + VirtualAddress)
  105.             StopVA = hex(ImageBase + VirtualAddress + VirtualSize)
  106.             print("[+] 代码段起始地址: {} 结束: {} 实际偏移:{} 长度: {}".format(StartVA, StopVA, ActualOffset, VirtualSize))
  108.             # 获取到.text节区间内的数据
  109.             hex_code = pe.write()[ActualOffset: VirtualSize]
  110.             return hex_code
  111.         else:
  112.             print("程序中不存在.text节")
  113.             return 0
  114.     return 0
  116. REGEX_STANDARD = '[\x09\x20-\x7E]'
  118. def ExtractStringsASCII(data):
  119.     regex = REGEX_STANDARD + '{%d,}'
  120.     return re.findall(regex % 4, data)
  122. def ExtractStringsUNICODE(data):
  123.     regex = '((' + REGEX_STANDARD + '\x00){%d,})'
  124.     return [foundunicodestring.replace('\x00', '') for foundunicodestring, dummy in re.findall(regex % 4, data)]
  126. # 将传入Hex字符串以每16字符分割在一个列表内
  127. def ExtractStrings(data):
  128.     return ExtractStringsASCII(data) + ExtractStringsUNICODE(data)
  130. if __name__ == "__main__":
  131.     pe = pefile.PE("d://lyshark.exe")
  133.     # 得到.text节内数据
  134.     ref = GetSectionHex(pe)
  136.     # 转为十六进制格式
  137.     dump_hex = HexDump(ref)
  138.     print(dump_hex)
  140.     # 打包为每16字符一个列表
  141.     dump_list = ExtractStrings(dump_hex)
  143.     print(dump_list)

21.1.6 解析数据目录表

数据目录表用于记录可执行文件的数据目录项在文件中的位置和大小。数据目录表共有16个条目，每个条目都对应着一个数据目录项，每个数据目录项都描述了可执行文件中某一部分的位置和大小。

数据目录表的解析可以使用pe.OPTIONAL_HEADER.NumberOfRvaAndSizes首先获取到数据目录表的个数，接着二通过循环个数依次解包OPTIONAL_HEADER.DATA_DIRECTORY里面的每一个列表，在循环列表时依次解包输出即可。

  1. import pefile
  3. # 将RVA转换为FOA的函数
  4. def RVAToFOA(pe,rva):
  5.     for item in pe.sections:
  6.         Section_Start = item.VirtualAddress
  7.         Section_Ends = item.VirtualAddress + item.SizeOfRawData
  8.         if rva >= Section_Start and rva < Section_Ends:
  9.             return rva - item.VirtualAddress + item.PointerToRawData
  10.     return -1
  12. # 扫描数据目录表
  13. def ScanOptional(pe):
  14.     optional_size = pe.OPTIONAL_HEADER.NumberOfRvaAndSizes
  15.     print("数据目录表个数: {}".format(optional_size))
  17.     print("-" * 100)
  18.     print("编号 \t\t\t 目录RVA\t\t 目录FOA\t\t\t 长度\t\t 描述信息")
  19.     print("-" * 100)
  21.     for index in range(0,optional_size):
  22.         va = int(pe.OPTIONAL_HEADER.DATA_DIRECTORY[index].VirtualAddress)
  23.         print("%03d \t\t 0x%08X\t\t 0x%08X\t\t %08d \t\t"
  24.               %(index,
  25.                 pe.OPTIONAL_HEADER.DATA_DIRECTORY[index].VirtualAddress,
  26.                 RVAToFOA(pe,va),
  27.                 pe.OPTIONAL_HEADER.DATA_DIRECTORY[index].Size
  28.                 ),end="")
  30.         if index == 0:
  31.             print("Export symbols")
  32.         if index == 1:
  33.             print("Import symbols")
  34.         if index == 2:
  35.             print("Resources")
  36.         if index == 3:
  37.             print("Exception")
  38.         if index == 4:
  39.             print("Security")
  40.         if index == 5:
  41.             print("Base relocation")
  42.         if index == 6:
  43.             print("Debug")
  44.         if index == 7:
  45.             print("Copyright string")
  46.         if index == 8:
  47.             print("Globalptr")
  48.         if index == 9:
  49.             print("Thread local storage (TLS)")
  50.         if index == 10:
  51.             print("Load configuration")
  52.         if index == 11:
  53.             print("Bound Import")
  54.         if index == 12:
  55.             print("Import Address Table")
  56.         if index == 13:
  57.             print("Delay Import")
  58.         if index == 14:
  59.             print("COM descriptor")
  60.         if index == 15:
  61.             print("NoUse")
  63. if __name__ == "__main__":
  64.     pe = pefile.PE("d://lyshark.exe")
  65.     ScanOptional(pe)

21.1.7 解析导入导出表

导入表和导出表都是PE文件中的重要数据结构，分别记录着一个模块所导入和导出的函数和数据，如下所示则是使用PeFile模块实现对导入表与导出表的解析工作，对于导入表ScanImport的解析需要通过pe.DIRECTORY_ENTRY_IMPORT获取到完整的导入目录，并通过循环的方式输出x.imports中的数据即可，而对于导出表ScanExport则需要在pe.DIRECTORY_ENTRY_EXPORT.symbols导出符号中解析获取。

  1. import pefile
  3. # 输出所有导入表模块
  4. def ScanImport(pe):
  5.     print("-" * 100)
  6.     try:
  7.         for x in pe.DIRECTORY_ENTRY_IMPORT:
  8.             for y in x.imports:
  9.                 print("[*] 模块名称: %-20s 导入函数: %-14s" %((x.dll).decode("utf-8"),(y.name).decode("utf-8")))
  10.     except Exception:
  11.         pass
  12.     print("-" * 100)
  14. # 输出所有导出表模块
  15. def ScanExport(pe):
  16.     print("-" * 100)
  17.     try:
  18.         for exp in pe.DIRECTORY_ENTRY_EXPORT.symbols:
  19.             print("[*] 导出序号: %-5s 模块地址: %-20s 模块名称: %-15s"
  20.             %(exp.ordinal,hex(pe.OPTIONAL_HEADER.ImageBase + exp.address),(exp.name).decode("utf-8")))
  21.     except:
  22.         pass
  23.     print("-" * 100)
  25. if __name__ == "__main__":
  26.     pe = pefile.PE("d://lyshark.exe")
  27.     ScanImport(pe)
  28.     ScanExport(pe)

本文作者： 王瑞
本文链接： https://www.lyshark.com/post/92a3370c.html
版权声明： 本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！

原文链接：https://www.cnblogs.com/LyShark/p/17775685.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Python热门文章

  • Python | 新冠肺炎疫情数据的爬取与可视化分析
  • Python爬小草1024图片，盖达尔的诱惑（urllib.request）
  • pytorch如何获得模型的计算量和参数量
  • 计算曲线与坐标轴的面积
  • 基于Python实现语音合成小工具
  • PyQt5笔记之弹出窗口大全
  • python反编译学习之字节码详解
  • Python爬虫基础讲解（二十）：多进程——multiprocessing模块的使用
  • python?OpenCV计算图片相似度的5种算法
  • matplotlib 设置图形大小时 figsize 与 dpi 的关系

    • Python推荐文章

  • python 音频处理（2)——提取PPG特征之whisper库的使用（2.1）
  • 《最新出炉》系列初窥篇-Python+Playwright自动化测试-60 - 判断元素是否显示 - 下篇 - 北京-宏哥
  • [python] 启发式算法库scikit-opt使用指北
  • 《最新出炉》系列初窥篇-Python+Playwright自动化测试-59 - 判断元素是否显示 - 上篇 - 北京-宏哥
  • 界面自动化测试录制工具，让python selenium自动化测试脚本开发更加方便
  • 《最新出炉》系列入门篇-Python+Playwright自动化测试-56- 多文件上传 - 下篇 - 北京-宏哥
  • 音频文件降噪及python示例
  • 全网最适合入门的面向对象编程教程：20 类和对象的 Python 实现-组合关系的实现与 CSV 文件保存
  • 张高兴的 MicroPython 入门指南：（一）环境配置、Blink、部署
  • Python——比 Seaborn 更好的相关性热力图：Biokit Corrplot

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号