一、说明

　　简述：本文将以4399小游戏《宠物连连看经典版2》作为测试案例，通过识别小图标，模拟鼠标点击，快速完成配对。对于有兴趣学习游戏脚本的同学有一定的帮助。

　　运行环境：Win10/Python3.5。

　　主要模块：win32gui（识别窗口、窗口置顶等操作）、PIL（屏幕截图）、numpy（创建矩阵）、operator（比较值）、pymouse（模拟鼠标点击）。

　　注意点：

　　　　　　1、如果安装pymouse不成功或者运行报错，可以考虑先通过whl 安装pyHook、然后再通过pip安装pyuserinput。

　　　　　　2、如果报错 [ImportError: No module named 'windows' ]，可以修改__init__.py相应的行 为 windows => pymouse.windows。

　　本文主要参考：https://baijiahao.baidu.com/s?id=1618385402903335091&wfr=spider&for=pc。

　　　　

二、开发前景（随便唠叨一哈，可跳过）

　　游戏辅助脚本在当前环境也算是比较流行了，对于经常玩游戏人来说，适当的游戏辅助还是很有帮助的，让计算机做一些繁琐乏味的操作。当然还有更加高大上的其他操作，这里就不赘述了。对于游戏辅助脚本，能想到基本有以下两种：一是读取游戏在内存中的数据，理想的话可以做到更改游戏一些基本属性，原理和很多的外挂或破解游戏类似；二是模拟用户用户行为，模拟鼠标点击、键盘操作等。当然，由于本人从未涉及游戏辅助脚本这一领域，出于个人兴趣，学习研究一下，本文例子则是第二种，主要还是模拟用户行为，让程序代替用户操作。

三、开发流程

　　先看看程序运行图吧：

　　

　　浏览器打开游戏窗口（单个一个窗口），游戏界面如下图所示，游戏主要界面截图需要两个坐标（左上角坐标和右下角坐标）来确定，原点一般是屏幕左上角，不确定坐标点值的同学，可以全屏截图，用编辑图片软件查看坐标值。获取窗口句柄，这里就是浏览器标题栏的标题了（右键-查看源代码-title，加上软件名）比如：“宠物连连看经典2,宠物连连看经典版2小游戏,4399小游戏 www.4399.com - Google Chrome“。获取窗口句柄就可以开始了。

　　总体开发思路：截取游戏主图 ---> 分割成小图 ---> 对比每个小图，对比图片相识度，编号存入矩阵 ---> 对矩阵进行可连计算 ---> 模拟点击。

　　

　　3.1、获取窗口句柄，把窗口置顶

　　　　python可以使用win32gui模块调用Windows API实现对窗口的操作，使用FindWindow()方法可以获取窗口的句柄（handle），需要传入两个参数，第一个为父窗口句柄（这里填0即可），第二个参数是窗口的名称（标签title - Google Chrome）。获取句柄之后然后通过SetForegroundWindows() 设置窗口在前面，这里传入游戏窗口的举报即可，代码如下：

  1.  import win32gui
  2.  
  3.  class GameAssist:
  4.  
  5.      def __init__(self, wdname):
  6.          """初始化"""
  7.  
  8.          # 取得窗口句柄
  9.          self.hwnd = win32gui.FindWindow(0, wdname)
  10.          if not self.hwnd:
  11.              print("窗口找不到，请确认窗口句柄名称：【%s】" % wdname )
  12.              exit()
  13.          # 窗口显示最前面
  14.          win32gui.SetForegroundWindow(self.hwnd)
  15.  
  16.  if __name__ == "__main__":
  17.      # wdname 为连连看窗口的名称，必须写完整
  18.      wdname = u'宠物连连看经典版2,宠物连连看经典版2小游戏,4399小游戏 www.4399.com - Google Chrome'
  19.  
  20.      demo = GameAssist(wdname)
  21.      demo.start()

　　　　　

　　3.2、截取游戏界面，分割图标，图片比较

　　　　这里需要花费一些时间来校验程序，如果截取的图片不好，则会影响后续操作，所以比较主要的是确认游戏左上角和右下角这两个坐标值，以及每个小图标的宽高。如下图所示，先截取整个游戏界面图，然后分割小图标，接着对每个图标进行比较，然后以编号代替图标存入矩阵（这里的编号矩阵和游戏图不一致，原理一样）。

　　　　

　　　　

　　　　根据初始化设定的左上角和右下角两个坐标，使用ImageGrab.grab()方法进行截图，传入一个元组即可，然后对这个大图进行分割，切割成一个个小图标存入到images_list数组中。　　　

  1.      def screenshot(self):
  2.          """屏幕截图"""
  3.  
  4.          # 1、用grab函数截图，参数为左上角和右下角左标
  5.          # image = ImageGrab.grab((417, 257, 885, 569))
  6.          image = ImageGrab.grab(self.scree_left_and_right_point)
  7.  
  8.          # 2、分切小图
  9.          # exit()
  10.          image_list = {}
  11.          offset = self.im_width  #
  12.  
  13.          # 8行12列
  14.          for x in range(8):
  15.              image_list[x] = {}
  16.              for y in range(12):
  17.                  # print("show",x, y)
  18.                  # exit()
  19.                  top = x * offset
  20.                  left = y * offset
  21.                  right = (y + 1) * offset
  22.                  bottom = (x + 1) * offset
  23.  
  24.                  # 用crop函数切割成小图标，参数为图标的左上角和右下角左边
  25.                  im = image.crop((left, top, right, bottom))
  26.                  # 将切割好的图标存入对应的位置
  27.                  image_list[x][y] = im
  28.  
  29.          return image_list

　　　　

　　　　通过上面代码切割的小图标，转成数字矩阵，如果图标已经存入image_type_list则返回这个索引，如果不存在，则在追加进去，然后当前长度就是这个新加入图标的编号，代码如下所示：

  1.      def image2num(self, image_list):
  2.          """将图标矩阵转换成数字矩阵"""
  3.  
  4.          # 1、创建全零矩阵和空的一维数组
  5.          arr = np.zeros((10, 14), dtype=np.int32)    # 以数字代替图片
  6.          image_type_list = []
  7.  
  8.          # 2、识别出不同的图片，将图片矩阵转换成数字矩阵
  9.          for i in range(len(image_list)):
  10.              for j in range(len(image_list[0])):
  11.                  im = image_list[i][j]
  12.  
  13.                  # 验证当前图标是否已存入
  14.                  index = self.getIndex(im, image_type_list)
  15.  
  16.                  # 不存在image_type_list
  17.                  if index < 0:
  18.                      image_type_list.append(im)
  19.                      arr[i + 1][j + 1] = len(image_type_list)
  20.                  else:
  21.                      arr[i + 1][j + 1] = index + 1
  22.  
  23.          print("图标数：", len(image_type_list))
  24.  
  25.          self.im2num_arr = arr
  26.          return arr

　　　　

　　　　上面的getIndex就是对比图片，判断图标是否出现过（是否已存在image_type_list中，没出现则追加进去），这里使用汉明距离判断两个图片的相识度，设置阀值10，当小于阀值则认为是同一个图片，具体代码如下：　　

  1.      # 检查数组中是否有图标,如果有则返回索引下表
  2.      def getIndex(self,im, im_list):
  3.          for i in range(len(im_list)):
  4.              if self.isMatch(im, im_list[i]):
  5.                  return i
  6.  
  7.          return -1
  8.  
  9.      # 汉明距离判断两个图标是否一样
  10.      def isMatch(self, im1, im2):
  11.  
  12.          # 缩小图标，转成灰度
  13.          image1 = im1.resize((20, 20), Image.ANTIALIAS).convert("L")
  14.          image2 = im2.resize((20, 20), Image.ANTIALIAS).convert("L")
  15.  
  16.          # 将灰度图标转成01串,即系二进制数据
  17.          pixels1 = list(image1.getdata())
  18.          pixels2 = list(image2.getdata())
  19.  
  20.          avg1 = sum(pixels1) / len(pixels1)
  21.          avg2 = sum(pixels2) / len(pixels2)
  22.          hash1 = "".join(map(lambda p: "" if p > avg1 else "", pixels1))
  23.          hash2 = "".join(map(lambda p: "" if p > avg2 else "", pixels2))
  24.  
  25.          # 统计两个01串不同数字的个数
  26.          match = sum(map(operator.ne, hash1, hash2))
  27.  
  28.          # 阀值设为10
  29.          return match < 10

　　　　　

四、程序核心-图标连接算法（路径寻找）

　　这里仅对算法代码进行简单分析，如果对程序不好理解，可以留言，后续可以图文分析。

　　通过上面的开发流程，基本获取如下这样的矩阵，只要比较两个编号相同的值进行可连路径寻找，如果找到即进行模拟点击操作。这里简单介绍下游戏规则：8行乘12列游戏图标区域，外围的0其实表示寻找路径的时候可以通过，例如坐标（1, 1）可以与（1,10）进行连接、（7, 1）和（7,2）进行连接。

  1.  arr = [
  2.      [ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
  3.      [ 0,  1,  2,  3,  4,  5,  4,  6,  7,  2,  1,  1,  8,  0],
  4.      [ 0,  9,  3,  3, 10,  4,  7, 11,  7,  2,  3,  1,  6,  0],
  5.      [ 0,  6,  7,  4, 11,  5,  8,  1,  6,  5,  4,  2,  8,  0],
  6.      [ 0,  6,  2,  9,  6,  8,  9,  7, 12, 11,  3, 11, 11,  0],
  7.      [ 0,  5,  9,  8,  9,  2,  6, 11, 11,  3,  9,  2, 12,  0],
  8.      [ 0, 12,  5, 12,  5, 10,  5,  6,  5,  7, 12,  4,  3,  0],
  9.      [ 0,  1,  8, 10, 12,  9, 10,  4,  3,  7,  2,  1, 10,  0],
  10.      [ 0,  1,  4, 10,  8, 12, 10, 10,  9, 12,  8,  7, 11,  0],
  11.      [ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0]
  12.  ]

　　

　　算法的思路：路径的寻找首先是寻找一个坐标的横向竖向可以直接相连的坐标集合，比如坐标p1（1,1）这样的集合有[ （0,1）, （1,0） ]，另外一个坐标p2（1,10）的可连集合为[ （0,10） ]，然后再对p1和p2的可连坐标集合进行比较，如果集合中坐标也有可连，则表示p1和p2可连，很明显，（0,1）和（0,10）为同一行且可连，这样就表示p1和p2两点存在可连路径了，代码如下所示：

　　简单分析下代码实现过程：在isReachable()传入两个需要比较的坐标值，然后分别获取两个点横竖向（isRowConnect()、isColConnect()）可以连接的坐标集合，最后再对集合进行遍历比较是否存在可连的，如果存在则表示传入的两个坐标是可以连接的。

  1.      # 是否为同行或同列且可连
  2.      def isReachable(self, x1, y1, x2, y2):
  3.          # 1、先判断值是否相同
  4.          if self.im2num_arr[x1][y1] != self.im2num_arr[x2][y2]:
  5.              return False
  6.  
  7.          # 1、分别获取两个坐标同行或同列可连的坐标数组
  8.          list1 = self.getDirectConnectList(x1, y1)
  9.          list2 = self.getDirectConnectList(x2, y2)
  10.          # print(x1, y1, list1)
  11.          # print(x2, y2, list2)
  12.  
  13.          # exit()
  14.  
  15.          # 2、比较坐标数组中是否可连
  16.          for x1, y1 in list1:
  17.              for x2, y2 in list2:
  18.                  if self.isDirectConnect(x1, y1, x2, y2):
  19.                      return True
  20.          return False
  21.  
  22.      # 获取同行或同列可连的坐标数组
  23.      def getDirectConnectList(self, x, y):
  24.  
  25.          plist = []
  26.          for px in range(0, 10):
  27.              for py in range(0, 14):
  28.                  # 获取同行或同列且为0的坐标
  29.                  if self.im2num_arr[px][py] == 0 and self.isDirectConnect(x, y, px, py):
  30.                      plist.append([px, py])
  31.  
  32.          return plist
  33.  
  34.      # 是否为同行或同列且可连
  35.      def isDirectConnect(self, x1, y1, x2, y2):
  36.          # 1、位置完全相同
  37.          if x1 == x2 and y1 == y2:
  38.              return False
  39.  
  40.          # 2、行列都不同的
  41.          if x1 != x2 and y1 != y2:
  42.              return False
  43.  
  44.          # 3、同行
  45.          if x1 == x2 and self.isRowConnect(x1, y1, y2):
  46.              return True
  47.  
  48.          # 4、同列
  49.          if y1 == y2 and self.isColConnect(y1, x1, x2):
  50.              return True
  51.  
  52.          return False
  53.  
  54.      # 判断同行是否可连
  55.      def isRowConnect(self, x, y1, y2):
  56.          minY = min(y1, y2)
  57.          maxY = max(y1, y2)
  58.  
  59.          # 相邻直接可连
  60.          if maxY - minY == 1:
  61.              return True
  62.  
  63.          # 判断两个坐标之间是否全为0
  64.          for y0 in range(minY + 1, maxY):
  65.              if self.im2num_arr[x][y0] != 0:
  66.                  return False
  67.          return True
  68.  
  69.      # 判断同列是否可连
  70.      def isColConnect(self, y, x1, x2):
  71.          minX = min(x1, x2)
  72.          maxX = max(x1, x2)
  73.  
  74.          # 相邻直接可连
  75.          if maxX - minX == 1:
  76.              return True
  77.  
  78.          # 判断两个坐标之间是否全为0
  79.          for x0 in range(minX + 1, maxX):
  80.              if self.im2num_arr[x0][y] != 0:
  81.                  return False
  82.          return True

　　

五、开发总结

　　学习这样一个游戏辅助脚本，对于个人培养编程兴趣也是有很多帮助的，在工作之余不失为一个好的消遣方式，以后会多向这些方向研究学习。本案例仅仅是截图、比较图片和模拟鼠标点击，我觉得还可以更加强大，而且还不局限于游戏这样一个领域，相信大家应该见过自动发QQ消息的软件吧，我觉得这完全可以做。还有很多模拟操作可以实现：鼠标滚轮，左右键、键盘输入等。

六、附件-源码

　　注意：源码仅供学习，转发注明出处，谢谢！

  1.  # -*- coding:utf-8 -*-
  2.  
  3.  import win32gui
  4.  import time
  5.  from PIL import ImageGrab, Image
  6.  import numpy as np
  7.  import operator
  8.  from pymouse import PyMouse
  9.  
  10.  class GameAssist:
  11.  
  12.      def __init__(self, wdname):
  13.          """初始化"""
  14.  
  15.          # 取得窗口句柄
  16.          self.hwnd = win32gui.FindWindow(0, wdname)
  17.          if not self.hwnd:
  18.              print("窗口找不到，请确认窗口句柄名称：【%s】" % wdname )
  19.              exit()
  20.  
  21.          # 窗口显示最前面
  22.          win32gui.SetForegroundWindow(self.hwnd)
  23.  
  24.          # 小图标编号矩阵
  25.          self.im2num_arr = []
  26.  
  27.          # 主截图的左上角坐标和右下角坐标
  28.          self.scree_left_and_right_point = (299, 251, 768, 564)
  29.          # 小图标宽高
  30.          self.im_width = 39
  31.  
  32.          # PyMouse对象，鼠标点击
  33.          self.mouse = PyMouse()
  34.  
  35.      def screenshot(self):
  36.          """屏幕截图"""
  37.  
  38.          # 1、用grab函数截图，参数为左上角和右下角左标
  39.          # image = ImageGrab.grab((417, 257, 885, 569))
  40.          image = ImageGrab.grab(self.scree_left_and_right_point)
  41.  
  42.          # 2、分切小图
  43.          # exit()
  44.          image_list = {}
  45.          offset = self.im_width  #
  46.  
  47.          # 8行12列
  48.          for x in range(8):
  49.              image_list[x] = {}
  50.              for y in range(12):
  51.                  # print("show",x, y)
  52.                  # exit()
  53.                  top = x * offset
  54.                  left = y * offset
  55.                  right = (y + 1) * offset
  56.                  bottom = (x + 1) * offset
  57.  
  58.                  # 用crop函数切割成小图标，参数为图标的左上角和右下角左边
  59.                  im = image.crop((left, top, right, bottom))
  60.                  # 将切割好的图标存入对应的位置
  61.                  image_list[x][y] = im
  62.  
  63.          return image_list
  64.  
  65.      def image2num(self, image_list):
  66.          """将图标矩阵转换成数字矩阵"""
  67.  
  68.          # 1、创建全零矩阵和空的一维数组
  69.          arr = np.zeros((10, 14), dtype=np.int32)    # 以数字代替图片
  70.          image_type_list = []
  71.  
  72.          # 2、识别出不同的图片，将图片矩阵转换成数字矩阵
  73.          for i in range(len(image_list)):
  74.              for j in range(len(image_list[0])):
  75.                  im = image_list[i][j]
  76.  
  77.                  # 验证当前图标是否已存入
  78.                  index = self.getIndex(im, image_type_list)
  79.  
  80.                  # 不存在image_type_list
  81.                  if index < 0:
  82.                      image_type_list.append(im)
  83.                      arr[i + 1][j + 1] = len(image_type_list)
  84.                  else:
  85.                      arr[i + 1][j + 1] = index + 1
  86.  
  87.          print("图标数：", len(image_type_list))
  88.  
  89.          self.im2num_arr = arr
  90.          return arr
  91.  
  92.      # 检查数组中是否有图标,如果有则返回索引下表
  93.      def getIndex(self,im, im_list):
  94.          for i in range(len(im_list)):
  95.              if self.isMatch(im, im_list[i]):
  96.                  return i
  97.  
  98.          return -1
  99.  
  100.      # 汉明距离判断两个图标是否一样
  101.      def isMatch(self, im1, im2):
  102.  
  103.          # 缩小图标，转成灰度
  104.          image1 = im1.resize((20, 20), Image.ANTIALIAS).convert("L")
  105.          image2 = im2.resize((20, 20), Image.ANTIALIAS).convert("L")
  106.  
  107.          # 将灰度图标转成01串,即系二进制数据
  108.          pixels1 = list(image1.getdata())
  109.          pixels2 = list(image2.getdata())
  110.  
  111.          avg1 = sum(pixels1) / len(pixels1)
  112.          avg2 = sum(pixels2) / len(pixels2)
  113.          hash1 = "".join(map(lambda p: "" if p > avg1 else "", pixels1))
  114.          hash2 = "".join(map(lambda p: "" if p > avg2 else "", pixels2))
  115.  
  116.          # 统计两个01串不同数字的个数
  117.          match = sum(map(operator.ne, hash1, hash2))
  118.  
  119.          # 阀值设为10
  120.          return match < 10
  121.  
  122.      # 判断矩阵是否全为0
  123.      def isAllZero(self, arr):
  124.          for i in range(1, 9):
  125.              for j in range(1, 13):
  126.                  if arr[i][j] != 0:
  127.                      return False
  128.          return True
  129.  
  130.      # 是否为同行或同列且可连
  131.      def isReachable(self, x1, y1, x2, y2):
  132.          # 1、先判断值是否相同
  133.          if self.im2num_arr[x1][y1] != self.im2num_arr[x2][y2]:
  134.              return False
  135.  
  136.          # 1、分别获取两个坐标同行或同列可连的坐标数组
  137.          list1 = self.getDirectConnectList(x1, y1)
  138.          list2 = self.getDirectConnectList(x2, y2)
  139.          # print(x1, y1, list1)
  140.          # print(x2, y2, list2)
  141.  
  142.          # exit()
  143.  
  144.          # 2、比较坐标数组中是否可连
  145.          for x1, y1 in list1:
  146.              for x2, y2 in list2:
  147.                  if self.isDirectConnect(x1, y1, x2, y2):
  148.                      return True
  149.          return False
  150.  
  151.      # 获取同行或同列可连的坐标数组
  152.      def getDirectConnectList(self, x, y):
  153.  
  154.          plist = []
  155.          for px in range(0, 10):
  156.              for py in range(0, 14):
  157.                  # 获取同行或同列且为0的坐标
  158.                  if self.im2num_arr[px][py] == 0 and self.isDirectConnect(x, y, px, py):
  159.                      plist.append([px, py])
  160.  
  161.          return plist
  162.  
  163.      # 是否为同行或同列且可连
  164.      def isDirectConnect(self, x1, y1, x2, y2):
  165.          # 1、位置完全相同
  166.          if x1 == x2 and y1 == y2:
  167.              return False
  168.  
  169.          # 2、行列都不同的
  170.          if x1 != x2 and y1 != y2:
  171.              return False
  172.  
  173.          # 3、同行
  174.          if x1 == x2 and self.isRowConnect(x1, y1, y2):
  175.              return True
  176.  
  177.          # 4、同列
  178.          if y1 == y2 and self.isColConnect(y1, x1, x2):
  179.              return True
  180.  
  181.          return False
  182.  
  183.      # 判断同行是否可连
  184.      def isRowConnect(self, x, y1, y2):
  185.          minY = min(y1, y2)
  186.          maxY = max(y1, y2)
  187.  
  188.          # 相邻直接可连
  189.          if maxY - minY == 1:
  190.              return True
  191.  
  192.          # 判断两个坐标之间是否全为0
  193.          for y0 in range(minY + 1, maxY):
  194.              if self.im2num_arr[x][y0] != 0:
  195.                  return False
  196.          return True
  197.  
  198.      # 判断同列是否可连
  199.      def isColConnect(self, y, x1, x2):
  200.          minX = min(x1, x2)
  201.          maxX = max(x1, x2)
  202.  
  203.          # 相邻直接可连
  204.          if maxX - minX == 1:
  205.              return True
  206.  
  207.          # 判断两个坐标之间是否全为0
  208.          for x0 in range(minX + 1, maxX):
  209.              if self.im2num_arr[x0][y] != 0:
  210.                  return False
  211.          return True
  212.  
  213.      # 点击事件并设置数组为0
  214.      def clickAndSetZero(self, x1, y1, x2, y2):
  215.          # print("click", x1, y1, x2, y2)
  216.  
  217.          # (299, 251, 768, 564)
  218.          # 原理：左上角图标中点 + 偏移量
  219.          p1_x = int(self.scree_left_and_right_point[0] + (y1 - 1)*self.im_width + (self.im_width / 2))
  220.          p1_y = int(self.scree_left_and_right_point[1] + (x1 - 1)*self.im_width + (self.im_width / 2))
  221.  
  222.          p2_x = int(self.scree_left_and_right_point[0] + (y2 - 1)*self.im_width + (self.im_width / 2))
  223.          p2_y = int(self.scree_left_and_right_point[1] + (x2 - 1)*self.im_width + (self.im_width / 2))
  224.  
  225.          time.sleep(0.2)
  226.          self.mouse.click(p1_x, p1_y)
  227.          time.sleep(0.2)
  228.          self.mouse.click(p2_x, p2_y)
  229.  
  230.          # 设置矩阵值为0
  231.          self.im2num_arr[x1][y1] = 0
  232.          self.im2num_arr[x2][y2] = 0
  233.  
  234.          print("消除：(%d, %d) (%d, %d)" % (x1, y1, x2, y2))
  235.          # exit()
  236.  
  237.      # 程序入口、控制中心
  238.      def start(self):
  239.  
  240.          # 1、先截取游戏区域大图，然后分切每个小图
  241.          image_list = self.screenshot()
  242.  
  243.          # 2、识别小图标，收集编号
  244.          self.image2num(image_list)
  245.  
  246.          print(self.im2num_arr)
  247.  
  248.          # 3、遍历查找可以相连的坐标
  249.          while not self.isAllZero(self.im2num_arr):
  250.              for x1 in range(1, 9):
  251.                  for y1 in range(1, 13):
  252.                      if self.im2num_arr[x1][y1] == 0:
  253.                          continue
  254.  
  255.                      for x2 in range(1, 9):
  256.                          for y2 in range(1, 13):
  257.                              # 跳过为0 或者同一个
  258.                              if self.im2num_arr[x2][y2] == 0 or (x1 == x2 and y1 == y2):
  259.                                  continue
  260.                              if self.isReachable(x1, y1, x2, y2):
  261.                                  self.clickAndSetZero(x1, y1, x2, y2)
  262.  
  263.  if __name__ == "__main__":
  264.      # wdname 为连连看窗口的名称，必须写完整
  265.      wdname = u'宠物连连看经典版2,宠物连连看经典版2小游戏,4399小游戏 www.4399.com - Google Chrome'
  266.  
  267.      demo = GameAssist(wdname)
  268.      demo.start()

GameAssist.py

[Python] 用python做一个游戏辅助脚本，完整思路的更多相关文章

  1. 基于七牛Python SDK写的一个批量下载脚本

    前言 上一篇基于七牛Python SDK写的一个同步脚本所写的脚本只支持上传,不支持文件下载. 虽然这个需求不太强烈,但有可能有人(在备份.迁移时)需要,而官方有没提供对应的工具,所以我就把这个功能也 ...

  2. 今天七夕节，外面下着大雨，用Python的tkinter做一个下爱心雨的特效，发给妹子

    今天七夕,还下着雨,刚好想做一个下着爱心雨的特效 准备图片素材 1.美图秀秀找一个爱心图,大小就50*50就可以,生成的是一个png格式文件 2.由于canvas.create_image只支持gif ...

  3. 教你如何使用Python写游戏辅助脚本

    主要实现方式是通过图片的对比,在游戏中就行点击.运行程序需要以下东西. PIL: 图片处理模块     (python3 换成了 pillow)  下载地址: https://www.lfd.uci. ...

  4. python+imageMagick写的一个压缩图片脚本

    !/usr/bin/python import os import cPickle as p import re import Image def imageCompre(imagedir = '.' ...

  5. 用HTML5的canvas做一个时钟

    对于H5来说,canvas可以说是它最有特色的一个地方了,有了它之后我们可以随意的在网页上画各种各样的图形,做一些小游戏啊什么的.canvas这个标签的用法,在网上也有特别多的教程了,这里就不作介绍了 ...

  6. 利用jquery+iframe做一个ajax上传效果

    以下是自学it网--中级班上课笔记 网址:www.zixue.it html页面 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict ...

  7. 用Python写一个游戏脚本，你会吗？

    前言本文的文字及图片来源于网络,仅供学习.交流使用,不具有任何商业用途,版权归原作者所有,如有问题请及时联系我们以作处理.作者:ivat4u  学习python有一段时间了,由于python语言的强大 ...

  8. 12岁的少年教你用Python做小游戏

    首页 资讯 文章 频道 资源 小组 相亲 登录 注册       首页 最新文章 经典回顾 开发 设计 IT技术 职场 业界 极客 创业 访谈 在国外 - 导航条 - 首页 最新文章 经典回顾 开发 ...

  9. 从0开始的Python学习013编写一个Python脚本

    通过之前的学习我们已经了解了Python的很多基础运用了,现在我们尝试着做一个有使用价值的小脚本. 问题 需求: 我想要一个可以给我备份重要文件的程序. 需求分析: 首先文件是有存储路径,文件的路径和 ...

随机推荐

  1. Python生成器和构造器

    什么是生成器? 参考link:http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/00 ...

  2. Centos7 安装Homestead环境

    问题1, ==> homestead-7: Waiting for machine to boot. This may take a few minutes... homestead-7: SS ...

  3. Javaweb入门 数据库第二天

    接着说昨天语法中提到的drop,delete和truncate的区别 drop用于删除库和表,不能用于删除表记录 delete和truncate都可以用于删除表记录,不能用于删除库和表 而delete ...

  4. centos7主机间免密登录、复制文件

    下面实例为三个节点间 1.分别在三个节点设置域名映射 vi /etc/hosts  在文件末尾追加 192.168.10.121 node1 192.168.10.122 node2 192.168. ...

  5. 传输层的TCP和UDP协议

    作者:HerryLo 原文永久链接: https://github.com/AttemptWeb... TCP/IP协议, 你一定常常听到,其中TCP(Transmission Control Pro ...

  6. Spring 源码学习(一)-容器的基础结构

    关注公众号,大家可以在公众号后台回复“博客园”,免费获得作者 Java 知识体系/面试必看资料 展示的代码摘取了一些核心方法,去掉一些默认设置和日志输出,还有大多数错误异常也去掉了,小伙伴想看详细代码 ...

  7. （通俗易懂小白入门）网络流最大流——EK算法

    网络流 网络流是模仿水流解决生活中类似问题的一种方法策略,来看这么一个问题,有一个自来水厂S,它要向目标T提供水量,从S出发有不确定数量和方向的水管,它可能直接到达T或者经过更多的节点的中转,目前确定 ...

  8. 使用 OpenSSL为WindowsServer远程桌面（RDP）创建自签名证书 (Self-signed SSL certificate)

    前言 笔者查阅很多资料,才写成此文章,如有错误,请读者们及时提出. 一般大家使用远程桌面(Remote Desktop)连接Windows Server时,总会有一个警告提示,如图1 图1 出现此警告 ...

  9. Chrome 开发工具之 Memory

    开发过程中难免会遇到内存问题,emmm... 本文主要记录一下Chrome排查内存问题的面板,官网也有,但有些说明和例子跟不上新的版本了,也不够详细...   !!! 多图预警!!!    简单的内存 ...

  10. 弹性盒子---CSS3布局方式

    1.弹性盒子/伸缩盒子 如果要使用弹性盒子属性,首先要将父级元素变成弹性盒子 Flex-direction 设置伸缩盒子的内部元素的排列方式 Row    从左到右安行排列 Column  从上到下按 ...