2017华为软件精英挑战赛

Tue, 20 Jun 2017 12:52:00 +0000

代码链接https://github.com/happyte/2017CodeCraft

离大赛结束已经过去1个月了，从3月份开始比赛到最终5月中旬的总决赛，历时72天。最后的结果挺好的，进了全国8强，取得了第6的成绩。了却本科做比赛期间一直未能进入全国决赛的遗憾。

首先介绍下今天大赛的题型，是基于华为现实SDN抽象出来的一个模型，在一个城市内分布一些服务器，通过网络链路服务消费者，成本耗费在服务器的购买，服务器档位费用，链路费用。最终要使得总成本最小。详细题目介绍在 http://codecraft.huawei.com 官网上。

初赛代码我们是基于启发式算法+最小费用流算法，启发式搜索用的是爬山法+邻域搜索，最小费用流算法是目前速度最快的网络单纯型。在比赛过程中很多人使用的费用流算法是zkw，zkw改为在原图上跑的话速度也是很快的，当时我们的底层算法就选用了效率最高的网络单纯型。

复赛:在初赛的基础上，复赛增加了档位约束条件，新增加降压策略和压档策略，最小费用流通过修改顶点势的方法改为在原图上跑，是初赛速度的5倍。在1200个点的图上90s时间内纯跑费用流的话大概能跑14、15w次。

决赛:题目改为双方博弈类型，第一轮产生的初始解很重要，需要优先评估服务器，删除一些不必要的服务器，而且需要对服务器的选择档位作出评估。博弈策略是预测自己的下一轮收益和对手的下一轮收益，需要抢夺的消费结点分类讨论，1-已经占领的，2-对手占领的，3-双方都没有占领的，模拟退火算法以双方的收益差作为目标函数，使得双方的收益差尽可能大。

华为的软挑确实是个好比赛，不过也出现了很多的意外情况，复赛现场的时候出现了网站被攻击的情况，决赛前几天官方的判题还一直有bug存在。不过最终都得到妥善解决了，希望以后的大赛能尽量避免这些意外情况。

在比赛过程中很考验一个团队的想法和快速编码能力，对于我们队来说，基本上每天都有一种要推倒重来的感觉，尝试各种不同的策略。因此就很考验写代码的速度了，如果方法不行的话赶紧尝试下一种方法。还有，给大家一个建议，如果确定了底层算法用哪种的话，尽量去找资料看效率最高的算法，对后期的成绩起到了重要作用。

最后附上一张团队照片，哈哈

基于python的火车票查询工具

Fri, 20 Jan 2017 12:30:00 +0000

效果图

1.只查询动车票

2.查询所有票

Github链接

代码链接为:https://github.com/happyte/tickets

接口设计

1.查询火车票，需要出发地点，目的点，日期和所乘列类型这几个参数，因此设计出的接口为python3 tickets.py [-gdtkz] , [-gdtkz] 代表查询的火车类型，该参数可叠加，例如-gd代表查询所有的动车和高铁。
2.python的docopt模块可以解析命令行的参数，代码如下:

"""命令行火车票查看器
Usage:
    tickets [-gdtkz] <from> <to> <date>
Options:
    -h,--help   显示帮助菜单
    -g          高铁
    -d          动车
    -t          特快
    -k          快速
    -z          直达
Example:
    tickets 北京 上海 2016-10-10
    tickets -dg 成都 南京 2016-10-10
"""
 from docopt import docent

 def cli():
      arguments = docopt(__doc__)
      print(arguments)

 if __name__ == '__main__':
     cli()

3.在命令行输入命令python3 tickets.py -dg 成都上海 2017-02-10输出的结果如下:

获取12306数据

1.用谷歌的chrome浏览器抓取下网页的数据

从上图中发现请求的url后面跟了4个参数，分别为leftTicketDTO.train_date=2017-02-07、leftTicketDTO.from_station=CDW、leftTicketDTO.to_station=SHH、purpose_codes=ADULT四个参数。

2.再抓取下response,结果如下:

所有的车次信息都在data这个字典中，0-10这个分别包含了每趟车的所有信息。

3.在请求的url中出发点和目的地都是英文缩写，例如上面的CDW和SHH，而我们在命令行中输入的是中文，那么需要通过中文查找到对应的英文缩写，这个用chrome抓取到的数据好像没找到。那么查看下网页源代码

点击进入第一个station_version=1.8994这个文件，进入之后看到该文件是所有车站对应的中文和英文缩写，但是只需要提取中文和英文的大写缩写，编写一个正则表达式提取。另外新建一个文件叫parse_station.py，代码如下:

 # -*- coding:utf-8 -*-
 import re
 import requests
 from pprint import print

 url = 'https://kyfw.12306.cn/otn/resources/js/framework/station_name.js?station_version=1.8994'
response = requests.get(url, verify=False)     # verify=False不验证证书
stations = re.findall(u'([\u4e00-\u9fa5]+)+\|([A-Z]+)', response.text)
pprint(dict(stations), indent=4)       # indent代表缩进

4.在命令行执行python3 parse_station.py > stations.py，就新建了一个stations.py文件里面生成了一个中文和英文缩写对应的字典，如下所示:

获取需要的信息

1.构造url请求，导入上面生成的stations.py文件

 from stations import stations

 def cli():
    arguments = docopt(__doc__)
    from_station = stations.get(arguments['<from>'])
    to_staion = stations.get(arguments['<to>'])
    date = arguments['<date>']
    url = 'https://kyfw.12306.cn/otn/leftTicket/queryZ?leftTicketDTO.train_date={}&leftTicketDTO.' \
          'from_station={}&leftTicketDTO.to_station={}&purpose_codes=ADULT'.\
        format(date, from_station, to_staion)
    response = requests.get(url, verify=False)

2.得到请求的json应答，因为上面说了所有的列车信息都在data字典内部，因此需要的信息在response.json()[‘data’]中。
3.创建一个类用于分析需要的数据，prettytable模块用于创建图形化表格，colorama模块用于给表格上色。

class TransCollection:
    header = '车次 车站 时间 历时 一等座 二等座 软卧 硬卧 硬座 无座'.split()

    def __init__(self, available_trains, options):
        self.availavle_trains = available_trains
        self.options = options

    def _get_duration(self, train_data):
        duration = train_data.get('lishi').replace(':', '小时')+'分'
        if duration.startswith('00'):
            return duration[4:]
        if duration.startswith('0'):
            return duration[1:]
        return duration

    @property
    def trains(self):
        for train in self.availavle_trains:
            train_data = train['queryLeftNewDTO']
            train_number = train_data['station_train_code'][0].lower()   # 开头转换成小写
            if not self.options or train_number in self.options:
                train = [
                    train_data['station_train_code'],              # 车次
                    '\n'.join([Fore.GREEN+train_data['from_station_name']+Fore.RESET,    # 车站
                               Fore.RED+train_data['to_station_name']+Fore.RESET]),
                    '\n'.join([Fore.GREEN+train_data['start_time']+Fore.RESET,           # 车站
                               Fore.RED+train_data['arrive_time']+Fore.RESET]),
                    self._get_duration(train_data),                # 历时
                    train_data['zy_num'],                          # 一等座
                    train_data['ze_num'],                          # 二等座
                    train_data['rw_num'],                          # 软卧
                    train_data['yw_num'],                          # 硬卧
                    train_data['yz_num'],                          # 硬座
                    train_data['wz_num'],                          # 无座
                ]
                yield train

    def pretty_print(self):
        pt = PrettyTable()
        pt._set_field_names(self.header)
        for train in self.trains:
            pt.add_row(train)
        print(pt)

4.创建一个上面类的对象，调用pretty_print函数，在cli函数中添加

def cli():
    arguments = docopt(__doc__)
    from_station = stations.get(arguments['<from>'])
    to_staion = stations.get(arguments['<to>'])
    date = arguments['<date>']
    url = 'https://kyfw.12306.cn/otn/leftTicket/queryZ?leftTicketDTO.train_date={}&leftTicketDTO.' \
          'from_station={}&leftTicketDTO.to_station={}&purpose_codes=ADULT'.\
        format(date, from_station, to_staion)
    response = requests.get(url, verify=False)
    options = ''.join([key for key, value in arguments.items() if value is True])
    TransCollection(response.json()['data'], options).pretty_print()

flask部署到阿里云

Wed, 11 Jan 2017 02:30:00 +0000

1.上周入手了阿里云，所以把前段时间写的flask程序部署到阿里云上，之前是部署到heroku上的，下面介绍下如何部署到阿里云上。
2.阿里云部署后的链接为:http://123.57.132.125, 欢迎大家使用。
3.把flask工程中的文件通过scp命令拷贝到阿里云下，我的工程下的app包、migrations包、config.py、manager.py和requirements.txt通过命令例如scp -r xxx(需要拷贝的文件) root@xxxxxx(阿里云ip):/(你希望安装的目录)。
4.来到拷贝到的阿里云目录下，建立虚拟坏境virtualenv venv ,激活虚拟坏境. venv/bin/activate。安装工程所有需要模块pip install -r requirements.txt。
5.在阿里云的/etc/init目录下新建一个配置文件例如sudo nano /etc/init/blog.conf,该文件可以在虚拟机打开时自动执行flask web程序，在该文件内写入:

description "My Blog service"

start on runlevel [2345]
stop on runlevel [!2345]

respawn
setuid root
setgid www-data

env PATH=/root/flask/venv/bin  # 坏境的路径
chdir /root/flask/             # 工作目录 

exec gunicorn -w 4 -b 127.0.0.1:8000 manager:app # 启动web服务器

6.启动blog.conf,输入命令sudo service blog start,查看是否启动成功。
7.配置nginx反向代理服务器，如果阿里云没有安装nginx，用apt-get install nginx 命令安装下，修改/etc/nginx/site-available/default文件，修改如下:

# /ect/nginx/sites-available/default

server {
    listen 80;
    server_name 10.211.55.10;

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
  }

8.重新启动nginx,输入命令sudo service nginx restart。
9.安装postgresql，apt-get install postresql，创建数据库输入命令createdb blogdb。
10.以上步骤都成功的话就可以部署你的flask程序了。

高德地图API展示Scrapy爬取的链家网房源

Sun, 25 Dec 2016 02:52:00 +0000

1.代码链接

https://github.com/happyte/buyhouse

2.最终效果图

3.实现思路

1.爬取的是链家网的成都地区的新房源，爬出房源的名字、价格、地址和url这四个。我是基于python的scrapy实现爬虫的。
2.在终端安装scrapy,使用命令pip install scrapy,安装完后新建项目scrapy startproject fangjia。
3.明确需要爬取的数据，在items.py文件中写入需要爬取的数据。在scrapy中，Item是用来抓取内容的容器，类似python中的字典

import scrapy

class FangjiaItem(scrapy.Item):
    FANGJIA_ADDRESS = scrapy.Field()    # 住房地址
    FANGJIA_NAME = scrapy.Field()       # 名字
    FANGJIA_PRICE = scrapy.Field()      # 房价
    FANGJIA_URL = scrapy.Field()        # 房源url

4.下面分析下网页，来到成都房源的首页，一共有19个分页，分页的url例如http://cd.fang.lianjia.com/loupan/nht1/，最后一个数字代表页数。查看网页源代码如下:

可以直接在该网页抓取我们想要的房名、地址、价格和url。我的方法是先抓取url,再进入具体网页抓取想要的数据。从上图可以看到a标签的href="/loupan/p_chaygceqaausi/" 即为我们想要的相对路径，拼接http://cd.fang.lianjia.com 成http://cd.fang.lianjia.com/loupan/p_chaygceqaausi/ 即为我们需要的url。

5.使用xpath抓取上面的a标签中的href，fang_links = response.xpath('//div[@class="list-wrap"]/ul[@id="house-lst"]/li/div[@class="pic-panel"]/a/@href').extract() 抓取一个页面的所有的url集合，遍历上面的集合，请求具体页面。
6.来到一个具体页面分析，抓取我们要的数据标签位置
房源名字
房源单价
房源地址

抓取的代码如下:

 name = response.xpath('//div[@class="name-box"]/a/@title').extract()[0]
        url = response.xpath('//div[@class="name-box"]/a/@href').extract()[0]
        price = response.xpath('//p[@class="jiage"]/span[@class="junjia"]/text()').extract()[0]
        address = response.xpath('//p[@class="where"]/span/@title').extract()[0]

7.把上面抓取的数据放入item中，创建一个items.py定义的FangjiaItem类对象，最终输出这个对象item

item['FANGJIA_NAME'] = name
item['FANGJIA_ADDRESS'] = address
item['FANGJIA_PRICE'] = price
item['FANGJIA_URL'] = 'http://cd.fang.lianjia.com'+url
yield item

8.在scrapy工程的settings.py文件中要设置如下代码:

ITEM_PIPELINES = {
	'fangjia.pipelines.FangjiaPipeline':300
}

高德地图API调用

采用高德地图对房源进行可视化操作，在工程根目录下创建demo.html文件，页面大框架可直接从示例中心复制：高德 JavaScript API 示例中心http://lbs.amap.com/api/javascript-api/example/map/map-show/。具体可以看我仓库中的demo.html文件。

objective-c多种排序算法图形化演示

Fri, 02 Dec 2016 02:30:00 +0000

前几天在码农网看到了一篇文章，关于讲objective-c的几种排序算法的图形化操作方式，自己也写了一份代码温习下排序算法。

代码链接

先添上我的代码仓库链接https://github.com/happyte/sort

选择排序

1.排序效果演示如下

2.选择排序的原理
2.1 假定第一个元素是”最小值”，往后遍历，发现比”最小值”要小的元素就两者进行交换,即最终要把找到的最小值放在第一个元素位置上。
2.2 上面保证第一个元素肯定是最小值，接着缩小范围从第二个元素开始且默认为最小值，不断往后遍历交换最小值。
2.3 选择排序保障每次都能找到一个最小元素放在指定位置
3.选择排序代码实现如下

    - (void)zs_selectSort:(ZSCompare)compare withCallback:(ZSExchange)exchange{
    if (self.count == 0) {
        return;
    }
    for (int i = 0; i < self.count; i++) {
        for (int j = i+1; j < self.count; j++) {
            if (compare(self[i],self[j])==NSOrderedDescending) {
                [self zs_exchangeWithIndexA:i indexB:j Change:exchange];
            }
        }
    }
}

冒泡排序

1.冒泡排序效果演示

2.冒泡排序原理
2.1 从第一个元素开始，比较相邻两个元素，如果后面一个元素比前面一个元素小，则两者进行交换（即小的在前，大的在后）。大的元素不断往后移动，最终最大的元素沉到最后一个位置。
2.2 去掉最后一个位置，从第一个元素开始继续执行上面的操作，不断循环直至完成。
2.3 冒泡排序保障每一次操作要把最大值放在最后。
3.冒泡排序代码实现

- (void)zs_bubbleSort:(ZSCompare)compare withCallback:(ZSExchange)exchange{
    if (self.count == 0) {
        return;
    }
    for (NSInteger i = self.count-1; i > 0; i --) {
        for (NSInteger j = 0; j < i; j++) {
            if (compare(self[j],self[j+1])==NSOrderedDescending) {
                [self zs_exchangeWithIndexA:j indexB:j+1 Change:exchange];
            }
        }
    }
}

插入排序

1.插入排序效果演示

2.插入排序原理
2.1 插入排序用一个数组实现的话，把数组分为无序区和有序区两个区间，开始有序区只有第一个元素，从第二个元素到最后一个元素都为乱序区。
2.2 从乱序区取出第一个元素，与有序区的最后一个元素（即乱序区的前一个元素比较），下面有3种情况。
- 2.2.1 如果比前一个元素要大，则有序区范围增加1，乱序区范围减去1。
- 2.2.2 如果与前一个元素相等，则可以继续与前二个元素比较，大的话就插入在该元素后面，相等继续与前三个元素比较吧，不可能比前二个元素小，因为每次排序都是保证有序区是按顺序排列的。其实相等可以不继续向前比较，直接插入在有序区末位。此时有序区增加1，无序区减去1。
- 2.2.3 如果比前一个元素要小，则先交换位置，继续比较取出的元素与前一个元素，如果还要小继续交换位置，相等则继续往前比较。把乱序区的元素插入到有序区的正确位置。
2.3 经过上面的过程，已经把乱序区的第一个元素插入到有序区，且有序区长度增加1，乱序区长度减去1，取出缩小范围后乱序区的第一个元素继续上面操作，直至范围不能缩小。
3.插入排序代码实现

   - (void)zs_insertSort:(ZSCompare)compare withCallback:(ZSExchange)exchange{
    if (self.count == 0) {
        return;
    }
    for (NSInteger i = 0; i < self.count-1; i++) {
        for (NSInteger j = i+1; j > 0; j--) {
            if (compare(self[j],self[j-1])==NSOrderedAscending) {
                [self zs_exchangeWithIndexA:j indexB:j-1 Change:exchange];
            }
            else{
                break;
            }
        }
    }
}

快速排序

1.快速排序图形化演示

2.这里讲解下最原始的快速排序方法，先介绍下三个概念
2.1 中间值(pivot)，第一次快速排序默认第一个值为中间值
2.2 左游标(i)，排序开始时第一个元素的位置为左游标，左游标不断向右移动
2.3 右游标(j)，排序开始时最后一个元素的位置为右游标，右游标不断向左移动
2.4 当左右游标重合的时候。
3.下面解释下元素是如何进行交换的,例如给出一个数组[37,28,5,14,75,25,89,22,11]
3.1 从右边游标(j)开始(即11元素所在位置)，向前找比中间值(37)小的元素，此时找到的数就是11,交换中间值(pivot)和右游标j对应的元素。交换完成后，数组变为[11,28,5,14,75,25,89,22,37]。此时左游标指向的元素变为11,11肯定比中间值(pivot)即37要小，所以左游标可以直接+1往后移动一位，左游标指向28，右游标指向37。
3.2 从左边游标(i)开始(即现在的28元素所在位置)，向后找比中间值(37)大的元素，找到的数是75，交换中间值(pivot)和左游标i对应的元素。交换完成后，数组变为[11,28,5,14,37,25,89,22,75]。左游标i此时指向中间值37，此时右游标指向的元素变为75,75肯定比中间值(pivot)即37要大，所以右游标可以直接-1往前移动一位,右游标指向22。
3.3 上面两步的结论就是从右游标j开始找比中间值(pivot)小的，交换完成后，左游标i向后移动一位(i++)。从左游标i开始找比中间值(pivot)大的，交换完成后，右游标j向前移动一位(j–)。
3.4 经过上面的排序，数组排序成为[11,28,5,14,37,25,89,22,75],左游标为中间值37的位置，右游标为22指向的位置。再次开始从右游标开始找比中间值37小的元素，找到的就是22。交换22与37，数组成为[11,28,5,14,22,25,89,37,75],左游标+1来到25元素位置,右游标指向37元素所在位置。再次从左游标开始向后找大的，找到的数为89，交换左游标位置的89和中间值37。数组成为[11,28,5,14,22,25,37,89,75]，右游标减1来到37位置。左游标也在37位置，此时左右游标重合第一次快速排序结束。
3.5 通过第一次快速排序使得，比中间值37小的数都在37元素的前面。比37大的数都在37元素的后面。第一次快速排序获得了中间值37元素的位置，第二次快速排序从第一个元素到37开始进行排序，即[11,28,5,14,22,25,37]进行排序，同样取第一个元素11为中间值，左游标为11所在位置，右游标为37所在位置。
快速排序是个递归的过程，上述的[11,28,5,14,22,25,37]全部排序完成后，会执行第一次快速排序得到的后面几个元素，即[89,75]数组进行快速排序。
4.快速排序代码实现如下:

   - (void)zs_quickSort:(ZSCompare)compare withCallback:(ZSExchange)exchange{
    if (self.count == 0) {
        return;
    }
    [self zs_quickSortWithLow:0 High:self.count-1 Compare:compare Callback:exchange];
}

//递归函数,必须有返回
- (void)zs_quickSortWithLow:(NSInteger)low High:(NSInteger)high Compare:(ZSCompare)compare Callback:(ZSExchange)exchange{
    if (low >= high) {
        return;
    }
    NSInteger pivotIndex = [self zs_pivotIndexWithLeft:low Right:high Compare:compare Callback:exchange];
    [self zs_quickSortWithLow:low High:pivotIndex-1 Compare:compare Callback:exchange];
    [self zs_quickSortWithLow:pivotIndex+1 High:high Compare:compare Callback:exchange];
}

- (NSInteger)zs_pivotIndexWithLeft:(NSInteger)left Right:(NSInteger)right Compare:(ZSCompare)compare Callback:(ZSExchange)exchange{
    NSInteger i = left;
    NSInteger j = right;
    id pivot = self[left];
    while (i < j) {
        //从右边找小的,如果右边大于等于pivot，则右游标向左移动
        while (i < j && compare(pivot,self[j])!= NSOrderedDescending) {
            j--;
        }
        //右边的值小于pivot
        if (i < j) {
            [self zs_exchangeWithIndexA:i indexB:j Change:exchange];
            i++;
        }
        //从左边找大的，如果左边小于等于pivot,则左游标向右移动
        while (i < j && compare(self[i],pivot)!=NSOrderedDescending) {
            i++;
        }
        //左边的值大于pivot
        if (i < j) {
            [self zs_exchangeWithIndexA:i indexB:j Change:exchange];
            j--;
        }
    
    }
    return i;
}

堆排序

1.堆排序图形化演示

2.首先可以把数组画成一个二叉树的形式，还是用[12,28,5,14,75,25,89,22,11]数组进行讲解。把数组画成二叉树，如下所示

3.堆排序首先要初始化一个大顶堆或小顶堆，大顶堆即父结点比子左结点和子右结点大，反之则为小顶堆。假设数组下标从0开始，父结点下标为i，子左结点下标为2i+1,子右结点下标为2i+2。我在写程序的时候给数组下标为0的位置添加了一个空值，那么父结点下标为i,子左结点下标为2i,子右结点下标为2i+1。
4.下面解释下如何构建大顶堆
- 4.1 从最后一个非叶子结点开始，即14开始，如果父结点(14)比子左右结点(22和11)中的最大值(22)小，那么父结点(14)与子左右结点的最大值(22)交换，交换结果如下：
- 4.2 如果交换后的14比它的子左右结点还要小的话，要继续沉底(交换后一定要满足大顶堆的特点)，可是这里它已经没有子左右结点。因此从倒数第二个非叶子结点(5)开始，5与子左右结点最大值(89)交换，交换结果如下:
- 4.3 接下来从非子结点28开始，与子左右结点最大值(75)交换
- 4.4 接下来从非子结点12开始，与子左右结点最大值(89)交换
- 4.5 交换后的12比子左右结点的最大值(25)要小，不满足大顶堆特点，需要继续沉底
4.6 经过上面几步，大顶堆已经构造出来了，最大的那个元素(89)在最顶端，交换第一个元素(89)和最后一个元素(11)，交换效果如下,交换后把89从这个二叉树中移除:

4.7 现在的二叉树显然不满足大顶堆特点，则第一个元素11需要继续沉底，与子左右结点的最大值(75)交换，结果如下:

4.8 交换后的11仍然需要继续沉底，与28交换

4.9 现在二叉树又满足大顶堆的特点了，交换第一个元素(75)与最后一个元素(14),交换后把最后一个元素从二叉树中删除。

4.10 再继续沉底第一个元素，直至范围不能缩小，就能得到正确的排序。
5.堆排序代码实现如下:

   - (void)zs_heapSort:(ZSCompare)compare withCallback:(ZSExchange)exchange{
    if (self.count == 0) {
        return;
    }
    [self insertObject:[[NSNull alloc]init] atIndex:0];
    //初始化最大堆排序
    for (NSInteger index = (self.count-1)/2; index > 0; index--) {
        [self sinkIndex:index bottomIndex:self.count-1 compare:compare Callback:exchange];
    }
    //第一次交换根结点与最后一个元素,然后不断沉底第一个元素
    for (NSInteger index = self.count-1; index > 1; index--) {
        [self zs_exchangeWithIndexA:1 indexB:index Change:exchange];
        [self sinkIndex:1 bottomIndex:index-1 compare:compare Callback:exchange];
    }
    [self removeObjectAtIndex:0];
}

//第一个参数是需要沉底的元素索引值，第二个元素是能允许沉底的最大索引值
- (void)sinkIndex:(NSInteger)currentIndex bottomIndex:(NSInteger)bottomIndex compare:(ZSCompare)compare Callback:(ZSExchange)exchange{
    //数组第一个数为空，就是为了子左结点刚好是2倍，子右节点是2倍+1
    for (NSInteger maxIndex = 2*currentIndex; maxIndex <= bottomIndex ; maxIndex *= 2) {
        //找到子左右节点的最大值，父节点与这个值比较,首先必须保证右节点要存在
        if ((maxIndex+1)<=bottomIndex && compare(self[maxIndex],self[maxIndex+1])==NSOrderedAscending) {
            ++ maxIndex;
        }
        //比较父结点与子左右节点的最大值，如果小于，则交换，否则break跳出
        if (compare(self[currentIndex],self[maxIndex])==NSOrderedAscending) {
            [self zs_exchangeWithIndexA:currentIndex indexB:maxIndex Change:exchange];
        }
        else{
            break;
        }
        //将当前需要改变的节点位置currentIndex变成maxIndex,这样就可以继续沉底
        currentIndex = maxIndex;
    }
}

iOS动画框架pop使用方法

Fri, 02 Dec 2016 02:30:00 +0000

pop支持4种动画类型：弹簧动画效果、衰减动画效果、基本动画效果和自定义动画效果。

弹簧动画效果

1.效果图如下:

2.控制器代码如下,首先用pod安装导入pop框架:

   #import "ViewController.h"
    #import <POP.h>

    @interface ViewController ()

    @end

    @implementation ViewController

    - (void)viewDidLoad {
        [super viewDidLoad];
        CALayer *layer        = [CALayer layer];
        layer.frame           = CGRectMake(0, 0, 50, 50);
        layer.backgroundColor = [UIColor cyanColor].CGColor;
        layer.cornerRadius    = 25.f;
        layer.position        = self.view.center;
        [self.view.layer addSublayer:layer];

        // 弹簧动画
        POPSpringAnimation *anim = [POPSpringAnimation animationWithPropertyNamed:kPOPLayerScaleXY];
        anim.toValue             = [NSValue valueWithCGPoint:CGPointMake(3.f, 3.f)];
        anim.springSpeed         = 0.f;
        [layer pop_addAnimation:anim forKey:nil];
    }

    @end

3.上述代码设置了弹簧对象的速度(springSpeed)、最终值大小(toValue)，最后图层对象layer添加弹簧对象。

衰减动画

1.衰减动画效果

2.实现代码：

    #import "ViewController.h"
    #import <POP.h>

    @interface ViewController ()<POPAnimationDelegate>

    @property(nonatomic) UIControl *dragView;

    @end

    @implementation ViewController

    - (void)viewDidLoad
    {
        [super viewDidLoad];

        // 初始化dragView
        self.dragView                    = [[UIControl alloc] initWithFrame:CGRectMake(0, 0, 100, 100)];
        self.dragView.center             = self.view.center;
        self.dragView.layer.cornerRadius = CGRectGetWidth(self.dragView.bounds)/2;
        self.dragView.backgroundColor    = [UIColor cyanColor];
        [self.view addSubview:self.dragView];
        [self.dragView addTarget:self
                      action:@selector(touchDown:)
            forControlEvents:UIControlEventTouchDown];

        // 添加手势
        UIPanGestureRecognizer *recognizer = [[UIPanGestureRecognizer alloc] initWithTarget:self
                                                                                 action:@selector(handlePan:)];
    [self.dragView addGestureRecognizer:recognizer];
    }

    - (void)touchDown:(UIControl *)sender {
        [sender.layer pop_removeAllAnimations];
    }

    - (void)handlePan:(UIPanGestureRecognizer *)recognizer {
        // 拖拽
        CGPoint translation = [recognizer translationInView:self.view];
        recognizer.view.center = CGPointMake(recognizer.view.center.x + translation.x,
                                         recognizer.view.center.y + translation.y);
        [recognizer setTranslation:CGPointMake(0, 0) inView:self.view];

        // 拖拽动作结束
        if(recognizer.state == UIGestureRecognizerStateEnded)
        {
            // 计算出移动的速度
            CGPoint velocity = [recognizer velocityInView:self.view];

            // 衰退减速动画
            POPDecayAnimation *positionAnimation = \
        [POPDecayAnimation animationWithPropertyNamed:kPOPLayerPosition];

            // 设置代理
            positionAnimation.delegate = self;

            // 设置速度动画
            positionAnimation.velocity = [NSValue valueWithCGPoint:velocity];

            // 添加动画
            [recognizer.view.layer pop_addAnimation:positionAnimation
                                         forKey:nil];
        }
    }

    @end

3.对拖拽对象添加了pan手势，根据手势的位置移动拖拽对象，recognizer.view.center = CGPointMake(recognizer.view.center.x + translation.x,recognizer.view.center.y + translation.y)之后要清零相对位置，即调用[recognizer setTranslation:CGPointMake(0, 0) inView:self.view]。在拖拽动作结束的时候，计算出相对速度设置给衰减动画对象。

基本动画效果

1.基本动画效果如下:

2.代码如下:

   #import "ViewController.h"
    #import <POP.h>

    @interface ViewController ()

    @end

    @implementation ViewController

    - (void)viewDidLoad
    {
        [super viewDidLoad];

        // 创建view
        UIView *showView            = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 100, 100)];
        showView.alpha              = 0.f;
        showView.layer.cornerRadius = 50.f;
        showView.center             = self.view.center;
        showView.backgroundColor    = [UIColor cyanColor];
    [self.view addSubview:showView];

        // 执行基本动画效果
        POPBasicAnimation *anim = [POPBasicAnimation animationWithPropertyNamed:kPOPViewAlpha];
        anim.timingFunction     = [CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionEaseInEaseOut];
        anim.fromValue          = @(0.0);
        anim.toValue            = @(1.0);
        anim.duration           = 4.f;
        [showView pop_addAnimation:anim forKey:nil];
    }

    @end

3.基本动画对象只需要设置起始值(fromValue)和最终值(toValue)以及持续时间(duration)就可以了。

POP动画综合实战

1.动画效果如下：

2.点击中间红色按钮，6个按钮从上面坠落。点击取消，6个按钮又从上边掉下消失。代码实现如下：

#import "BSPublishController.h"
#import "BSVerticalButton.h"
#import <POP.h>

@interface BSPublishController ()
@property(nonatomic,weak)UIImageView *sloganView;
@end

@implementation BSPublishController

- (void)viewDidLoad {
    [super viewDidLoad];
    //添加6个按钮
    NSArray *name = @[@"发视频",@"发图片",@"发段子",@"发声音",@"审帖",@"离线下载"];
    NSArray *imageName = @[@"publish-video",@"publish-picture",@"publish-text",@"publish-audio",@"publish-review",@"publish-offline"];
    NSUInteger count = name.count;
    NSUInteger maxCols = 3;
    CGFloat buttonW = 72;
    CGFloat buttonH = buttonW + 50;
    CGFloat buttonStartX = 20;
    CGFloat buttonStartY = (BSScreenH-2*buttonH)*0.5;
    CGFloat buttonMargin = (BSScreenW-2*buttonStartX-buttonW*maxCols)/(maxCols-1);
    for (NSUInteger i = 0; i < count; i++) {
        BSVerticalButton *button = [[BSVerticalButton alloc]init];
        [button setImage:[UIImage imageNamed:imageName[i]] forState:UIControlStateNormal];
        [button setTitle:name[i] forState:UIControlStateNormal];
        [button setTitleColor:[UIColor blackColor] forState:UIControlStateNormal];
        button.titleLabel.font = [UIFont systemFontOfSize:14];
        button.tag = i;
        [button addTarget:self action:@selector(btnClick:) forControlEvents:UIControlEventTouchUpInside];
        [self.view addSubview:button];
        //计算frame
        NSUInteger row = i/maxCols;
        NSUInteger col = i%maxCols;
        CGFloat buttonX = buttonStartX + col*(buttonW+buttonMargin);
        CGFloat buttonY = buttonStartY + row*buttonH;
        //使用pop框架，改变frame往下掉,而且不需要再设置frame了，因为pop改变了frame
        POPSpringAnimation *anim = [POPSpringAnimation animationWithPropertyNamed:kPOPViewFrame];
        anim.fromValue = [NSValue valueWithCGRect:CGRectMake(buttonX, buttonY-BSScreenH, buttonW, buttonH)];
        anim.toValue   = [NSValue valueWithCGRect:CGRectMake(buttonX, buttonY, buttonW, buttonH)];
        anim.springBounciness = 8;
        anim.springSpeed = 8;
        anim.beginTime = CACurrentMediaTime()+0.1*i;
        [button pop_addAnimation:anim forKey:nil];
    }
    //添加顶部图片
    UIImageView *slogan = [[UIImageView alloc]initWithImage:[UIImage imageNamed:@"app_slogan"]];
    self.sloganView = slogan;
    [self.view addSubview:slogan];
    //中心约束
    POPSpringAnimation *anim = [POPSpringAnimation animationWithPropertyNamed:kPOPViewCenter];
    anim.fromValue = [NSValue valueWithCGPoint:CGPointMake(BSScreenW*0.5, BSScreenH*0.2-BSScreenH)];
    anim.toValue   = [NSValue valueWithCGPoint:CGPointMake(BSScreenW*0.5, BSScreenH*0.2)];
    anim.springBounciness = 8;
    anim.springSpeed = 8;
    anim.beginTime = CACurrentMediaTime()+0.1*count;
    [slogan pop_addAnimation:anim forKey:nil];

}

上面没有单独设置按钮的frame,而是在pop对象的属性(fromValue和toValue)里进行了设置。这里重写了Button按钮，重写的代码如下:

#import "BSVerticalButton.h"

@implementation BSVerticalButton

- (instancetype)initWithFrame:(CGRect)frame {
    if (self == [super initWithFrame:frame]) {
        self.titleLabel.textAlignment = NSTextAlignmentCenter;
    }
    return self;
}

- (void)awakeFromNib {
    self.titleLabel.textAlignment = NSTextAlignmentCenter;
}

//这个是控件重新布局，所以要调用layoutSubviews，而修改控件大小，是调用setFrame
- (void)layoutSubviews {

    [super layoutSubviews];
    self.imageView.x = 0;
    self.imageView.y = 0;
    self.imageView.width = self.width;
    self.imageView.height = self.imageView.width;
    
    self.titleLabel.x = 0;
    self.titleLabel.y = self.imageView.height;
    self.titleLabel.width = self.width;
    self.titleLabel.height = self.height - self.width;
}

- (void)setFrame:(CGRect)frame {
    [super setFrame:frame];
}
@end

点击取消6个按钮从上面掉下来，代码如下:

   - (void)cancel:(void(^)(int))completeion{
    //让按钮往下掉
    NSUInteger index = 2;
    NSUInteger count = self.view.subviews.count;

    for (NSUInteger i = index; i<count ; i++) {
        UIView *subview = self.view.subviews[i];
        //这里不需要计算frame，因为已经添加到view中，只需要设置最后的位置
        POPBasicAnimation *anim = [POPBasicAnimation animationWithPropertyNamed:kPOPViewCenter];
        anim.toValue  = [NSValue valueWithCGPoint:CGPointMake(subview.centerX, subview.centerY+BSScreenH)];
        anim.beginTime = CACurrentMediaTime()+0.1*i;
        [subview pop_addAnimation:anim forKey:nil];
        if (i == count-1) {
            //最后一个控件pop完退出控制器，写在外面会直接退出
            [anim setCompletionBlock:^(POPAnimation *anim, BOOL finished) {
                if (completeion) {
                    
                }
                [self dismissViewControllerAnimated:NO completion:nil];
            }];
        }
    }
}

Python微信飞机大战

Sat, 01 Oct 2016 12:52:00 +0000

基础类的构建

导弹类

1.导弹是从飞机上发射的(无论是玩家的飞机还是敌机),导弹的位置需要根据飞机的位置确定，还需要根据是玩家飞机还是敌机确定导弹的图片名和发射方向，因此需要传入图片名和位置参数。

#定义导弹类
class Bullet(object):
	"""Bullet"""
	def __init__(self, planeName,x,y):
		if planeName == 'enemy':        #敌机导弹向下打
			self.imageName = 'Resources/bullet-3.png'
			self.direction = 'down'
		elif planeName == 'hero':       #英雄飞机导弹向上打
			self.imageName = 'Resources/bullet-1.png'
			self.direction = 'up'
		self.image = pygame.image.load(self.imageName).convert()
		self.x = x
		self.y = y

pygame框架加载图片为图像函数为:pygame.image.load(image).convert(),传入的参数是图片的相对路径。

2.描绘出导弹的位置，导弹并且需要在初始化的self.x和self.y基础上移动位置,位置是在屏幕上描绘的，需要传入屏幕参数。

def draw(self,screen):
		if self.direction == 'down':
			self.y += 8
		elif self.direction == 'up':
			self.y -= 8
		screen.blit(self.image,(self.x,self.y))

pygame显示图片函数为:

   screen.blit(self.image,(self.x,self.y))
   pygame.display.update()

第一个参数为加载的图像，第二个参数为左上角坐标。两个函数是配合使用的，需要第二个函数去刷新界面。

飞机类

1.Plane类是接下来要创建的玩家类Hero和敌机类Enemy的基类。基类把两者共同的属性和方法定义出来，方便子类继承。飞机要发射导弹，有一定的发射间隔，因此定义一个对象属性self.bulletSleepTime。还需要一个列表存储导弹，定义一个对象属性为空列表self.bulletList。

#定义一个飞机基类		
class Plane(object):
	"""Plane"""
	def __init__(self):
		#导弹间隔发射时间1s
		self.bulletSleepTime = 0.3
		self.lastShootTime = time.time()
		#存储导弹列表
		self.bulletList = []

2.在初始化的时候我们定义了导弹的发射间隔时间，大于间隔时间的话我们就往定义的列表中添加导弹对象，因为我现在只想让玩家飞机发射子弹，因此初始化导弹对象特意往self.x加了36(是玩家飞机72x72图片宽度的一半)。让导弹在玩家飞机的正中间开始显示。

def shoot(self):
		if time.time()-self.lastShootTime>self.bulletSleepTime:
			self.bulletList.append(Bullet(self.planeName,self.x+36,self.y))
			self.lastShootTime = time.time()

3.描绘出飞机的位置

#描绘飞机
	def draw(self,screen):
		screen.blit(self.image,(self.x,self.y))

继承类的构建

玩家飞机类

1.在飞机基类中我们定义了一些共同的对象属性，不同的对象属性有图像和原始位置，而且玩家飞机类对象还想拥有基类对象的属性，所以需要调用Plane.__init__(self)函数，通过这个函数就拥有了Plane基类的对象属性bulletSleepTime、lastShootTime、bulletList。

#玩家飞机类，继承基类
class Hero(Plane):
	"""Hero"""
	def __init__(self):
		Plane.__init__(self)
		planeImageName = 'Resources/hero.png'
		self.image = pygame.image.load(planeImageName).convert()
		#玩家原始位置
		self.x = 200
		self.y = 600
		self.planeName = 'hero'

2.玩家飞机通过键盘的上下左右控制飞机的位置

#键盘控制自己飞机
	def keyHandle(self,keyValue):
		if keyValue == 'left':
			self.x -= 50
		elif keyValue == 'right':
			self.x += 50
		elif keyValue == 'up':
			self.y -= 50
		elif keyValue == 'down':
			self.y += 50

敌人飞机类

1.敌人飞机类中还多了速度对象属性，考虑到随着游戏难度的增加，敌人飞机速度越来越快，这个参数需要外界传入。而且敌人飞机有小中大三种类型，是随机的，起始的位置x轴也是随机的，y轴固定从最上方开始。

class Enemy(Plane):
	"""docstring for Enemy"""
	def __init__(self,speed):
		super(Enemy, self).__init__()
		randomImageNum = random.randint(1,3)
		planeImageName = 'Resources/enemy-' + str(randomImageNum) + '.png'
		self.image = pygame.image.load(planeImageName).convert()
		#敌人飞机原始位置
		self.x = random.randint(20,400)    #敌机出现的位置任意
		self.y = 0
		self.planeName = 'enemy'
		self.direction = 'down'     #用英文表示
		self.speed = speed          #移动速度,这个参数现在需要传入

2.敌人的飞机不断往下掉，改变self.y,其实不用判断，direction没有用到

def move(self):
		if self.direction == 'down':
			self.y += self.speed     #飞机不断往下掉

游戏初始化类(封装功能)

1.GameInit类创建了几个类属性，g_enemyList列表用于存储敌人飞机对象，初始化玩家对象hero=object，object是元类，和用于统计玩家分数的属性score。

   #类属性
   gameLevel = 1       #简单模式
   g_ememyList = []    #前面加上g类似全局变量
   score = 0           #用于统计分数
   hero = object

2.接下来定义了几个类方法和静态方法，用于封装功能，在主函数里调用的都是这些类方法和静态方法
- 往敌机列表中添加敌机对象,忽略下我的代码英语好像打错了

@classmethod
	def createEnemy(cls,speed):
		cls.g_ememyList.append(Enemy(speed))

创建玩家飞机对象

@classmethod
	def createHero(cls):
		cls.hero = Hero()

游戏初始化

@classmethod
	def gameInit(cls):
		cls.createHero()

玩家飞机对象处理键盘操作，在玩家飞机类中已经定义了键盘处理函数，这里再封装一层

@classmethod
	def heroPlaneKey(cls,keyValue):
		cls.hero.keyHandle(keyValue)

更新敌人飞机位置，敌人飞机对象都在g_enemyList列表中

@classmethod
	def setXY(cls):
		for i in cls.g_ememyList:
			i.move()

有3种类型的对象需要描绘，玩家飞机对象，敌人飞机对象和导弹，这个函数就是用来描绘这些对象，其中导弹和敌机需要判断哪些对象超出屏幕从列表中删除,这里用了del函数，记录下索引值并从列表中删除，同样也可以用pop函数,这里的j为索引值。

 @classmethod
	def draw(cls,screen):
		delPlaneList = []
		j = 0
		for i in cls.g_ememyList:
			i.draw(screen)   #画出敌机
			#敌机超过屏幕就从列表中删除
			if i.y > 680:
				delPlaneList.append(j)
			j += 1
		for m in delPlaneList:
			del cls.g_ememyList[m]


		delBulletList = []
		j = 0
		cls.hero.draw(screen)    #画出英雄飞机位置
		for i in cls.hero.bulletList:
			#描绘英雄飞机的子弹，超出window从列表中删除
			i.draw(screen)
			if i.y < 0:
				delBulletList.append(j)
			j += 1
		#删除加入到delBulletList中的导弹索引,是同步的
		for m in delBulletList:
			del cls.hero.bulletList[m]

玩家飞机对象发射子弹，同时也要判断打中了敌机就让敌机对象和和子弹对象同时从列表中删除。通过pygame.Rect(self.image.get_rect())获得矩形的值，但是只获得了图像的width和height两个属性，前两个属性left和top都为0，因此还需要设置这两个属性，然后通过collidetect判断两个矩形是否有相交处，其中索引值enemyIndex和bulletIndex需要仔细分析下。

#自己飞机发射子弹
	@classmethod
	def shoot(cls):
		cls.hero.shoot()
		#子弹打到敌机让敌机从列表中消失
		ememyIndex = 0
		for i in cls.g_ememyList:
			enemyRect = pygame.Rect(i.image.get_rect())
			enemyRect.left = i.x
			enemyRect.top  = i.y
			bulletIndex = 0
			for j in cls.hero.bulletList:
				bulletRect = pygame.Rect(j.image.get_rect())
				bulletRect.left = j.x
				bulletRect.top  = j.y
				if enemyRect.colliderect(bulletRect):
					#判断敌机的宽度或者高度，来知道打中哪种类型的敌机
					if enemyRect.width == 39:
						cls.score += 1000     #小中大飞机分别100,500,1000分
					elif enemyRect.width == 60:
						cls.score += 5000
					elif enemyRect.width == 78:
						cls.score += 10000
					cls.g_ememyList.pop(ememyIndex)        #敌机删除
					cls.hero.bulletList.pop(bulletIndex)   #打中的子弹删除
				bulletIndex += 1
			ememyIndex += 1

判断玩家飞机是否与敌机相撞判断游戏是否结束

#判断游戏是否结束
	@classmethod
	def gameover(cls):
		heroRect = pygame.Rect(cls.hero.image.get_rect())
		heroRect.left = cls.hero.x
		heroRect.top  = cls.hero.y
		for i in cls.g_ememyList:
			enemyRect = pygame.Rect(i.image.get_rect())
			enemyRect.left = i.x
			enemyRect.top  = i.y
			if heroRect.colliderect(enemyRect):
				return True
		return False

3.几个静态方法，静态方法不需要cls这个参数,通过类和实例都可以调用
退出整个程序

@staticmethod
	def terminate():
		pygame.quit()
		sys.exit(0)

进入游戏后可以按space键停止游戏，其实就是就是个死循坏，按键按下后跳出函数

@staticmethod
	def pause(surface,image):
		surface.blit(image,(0,0))
		pygame.display.update()
		while True:
			for event in pygame.event.get():
				if event.type == pygame.QUIT:
					cls.terminate()
				elif event.type == pygame.KEYDOWN:
					if event.key == K_SPACE:
						return

游戏开始后和结束后把分数显示出来,第一个参数是分数，第二个参数是通过pygame的字体库创建出来的，例如font = pygame.font.SysFont(None,64),参数分别为字体样式和大小，可以选择字体样式例如arial、simsun(宋体)，第三个参数是屏幕，第四和第五个参数是字体显示的left和top值。

@staticmethod
	def drawText(text,font,surface,x,y):
		#参数1：显示的内容 |参数2：是否开抗锯齿，True平滑一点|参数3：字体颜色|参数4：字体背景颜色
		content = font.render(text,False,(10,100,200))
		contentRect = content.get_rect()
		contentRect.left = x
		contentRect.top  = y
		surface.blit(content,contentRect)

主函数

1.运行一个模块，有if __name__ == 'main':标识，会直接运行里面的代码。第一步初始化pygame库，调用pygame.init(),第二步创建一个窗口与背景图拍呢一样大:screen = pygame.display.set_mode((ScreenWidth,ScreenHeight),0,32),然后可以设置窗口标题:pygame.display.set_caption('飞机大战')，第三步做一些初始化常量设置。其中纪录了游戏开始的时间，因为按照我的思想游戏开始后难度会逐渐增加，我是通过时间来增加难度的,启动时显示start图片，直到Enter键按下才进入游戏。

if __name__ == '__main__':
    #初始化pygame
    pygame.init()
    #创建一个窗口与背景图片一样大
    ScreenWidth,ScreenHeight = 460,680
    easyEnemySleepTime = 1      #简单模式下每隔1s创建新的敌机
    middleEnemySleepTime = 0.5 
    hardEnemySleepTime = 0.25
    lastEnemyTime  = 0
    screen = pygame.display.set_mode((ScreenWidth,ScreenHeight),0,32)
    pygame.display.set_caption('飞机大战')
    #参数1：字体类型，例如"arial"  参数2：字体大小
    font  = pygame.font.SysFont(None,64)
    font1 = pygame.font.SysFont("arial",24)
    #记录游戏开始的时间
    startTime = time.time()
    #背景图片加载并转换成图像
    background = pygame.image.load("Resources/bg_01.png").convert()   #背景图片
    gameover = pygame.image.load("Resources/gameover.png").convert()  #游戏结束图片
    start = pygame.image.load("Resources/startone.png")               #游戏开始图片
    gamePauseIcon = pygame.image.load("Resources/Pause.png")
    gameStartIcon = pygame.image.load("Resources/Start.png")
    screen.blit(start,(0,0))
    pygame.display.update()       #开始显示启动图片，直到有Enter键按下才会开始
    GameInit.waitForKeyPress()
    #初始化
    GameInit.gameInit()

2.进入while循坏后，调用游戏初始化类封装好的函数，通过时间间隔interval选定游戏困难模式，通过改变敌机刷新的时间和敌机的速度增加难度，游戏结束后，再次按下Enter按键退出程序。这里存在一个bug,一旦游戏进行过程中按下Space暂停游戏，interval时间间隔仍然再计算(按道理应该让时间暂停)，再次按下Space恢复游戏后，当前模式设定时间减少了或者进入更困难模式了。

while True:
    	screen.blit(background,(0,0))    #不断覆盖，否则在背景上的图片会重叠
    	screen.blit(gameStartIcon,(0,0))
    	GameInit.drawText('score:%s' % (GameInit.score),font1,screen,80,15)
    	for event in pygame.event.get():
    		#print(event.type)
    		if event.type == pygame.QUIT:
    			GameInit.terminate()
    		elif event.type == KEYDOWN:
    			if event.key == K_LEFT:
    				GameInit.heroPlaneKey('left')
    			elif event.key == K_RIGHT:
    				GameInit.heroPlaneKey('right')
    			elif event.key == K_UP:
    				GameInit.heroPlaneKey('up')
    			elif event.key == K_DOWN:
    				GameInit.heroPlaneKey('down')
    			elif event.key == K_SPACE:
    				GameInit.pause(screen,gamePauseIcon) #难度选择方面有bug.因为时间一直继续
    	interval = time.time() - startTime
    	# easy模式
    	if interval < 10:
    		if time.time() - lastEnemyTime >= easyEnemySleepTime:
    			GameInit.createEnemy(5)   #传入的参数是speed
    			lastEnemyTime = time.time()
    	# middle模式
    	elif interval >= 10 and interval < 30:
    		if time.time() - lastEnemyTime >= middleEnemySleepTime:
    			GameInit.createEnemy(10)
    			lastEnemyTime = time.time()
    	# hard模式
    	elif interval >= 30:
    		if time.time() - lastEnemyTime >= hardEnemySleepTime:
    			GameInit.createEnemy(13)
    			lastEnemyTime = time.time()
    	GameInit.shoot()
    	GameInit.setXY()
    	GameInit.draw(screen)    #描绘类的位置
    	pygame.display.update()  #不断更新图片
    	if GameInit.gameover():
    		time.sleep(1)        #睡1s时间,让玩家看到与敌机相撞的画面
    		screen.blit(gameover,(0,0))
    		GameInit.drawText('%s' % (GameInit.score),font,screen,170,400)
    		pygame.display.update()
    		GameInit.waitForKeyPress()
    		break

总结

1.我用的版本是python3.5,不知道为什么无法导入音乐，提示我打不开音乐文件，目前还没试过其它版本，猜测是否是因为版本的原因
2.接下来修复bug,目前完成了基本功能，下一步加入敌机爆炸效果和大型敌机是需要好几发子弹才能击毁