Welcome to LeaCoder's Blog!

持之以恒终有收获，自律自强方至成功

Python编程从入门到实践：外星人入侵

2019-03-31

leacoder

程序员练级之旅

开发系统和开发IDE
资料《Python编程从入门到实践》书籍
相关问题以及解决
相关第三方库
GitHub:
目录文件结构

开发系统和开发IDE

开发系统： Ubuntu 16.0.4 LTS

开发IDE： Visual Studio Code 版本: 1.32.3

Python版本： Python3

依赖库： pygame

资料《Python编程从入门到实践》书籍

链接：https://pan.baidu.com/s/1USkqvL2dLU3Q9XplVaGQJg

提取码：zoyc

GitHub:

https://github.com/lichangke/Python3_Project/tree/master/alien_invasion

目录文件结构

#	文件名	内容
-	.vscode	VSCode 配置
-	images文件夹	存放所需图片
-	alien.py	外星人属性，加载绘制移动以及边缘检测相关
-	alien_invasion.py	程序入口，初始化游戏，循环事件检测以及绘制更新游戏屏幕
-	bullet.py	子弹属性，位置更新和绘制
-	button.py	开始按钮属性，绘制
-	game_functions.py	存储大量让游戏运行的函数，响应按键和鼠标事件，更新屏幕上的图像，其他逻辑计算与处理
-	game_stats.py	游戏运行状态信息，活动状态，分数和级别状态
-	scoreboard.py	得分信息，显示当前和最高分数
-	settings.py	游戏参数设置，飞船外星人记分子弹游戏速度等设置
-	ship.py	飞船属性，位置更新和绘制

运行与效果

在 alien_invasion 文件夹中，终端命令:

python3 alien_invasion.py 需要linux系统以及Python3 和依赖库pygame支持

点击 Play 开始方向键左右移动空格发射子弹 (同时最多3发) settings.py-> self.bullets_allowed = 3 # 限制子弹数目退出按 Q

alien.py

import pygame
from pygame.sprite import Sprite

class Alien(Sprite):
    """表示单个外星人的类"""
    def __init__(self, ai_settings, screen):
        """初始化外星人并设置其起始位置"""
        super(Alien,self).__init__()
        self.screen = screen
        self.ai_settings = ai_settings

        # 加载外星人图像， 并设置其rect属性
        self.image = pygame.image.load('images/alien.bmp')
        self.rect = self.image.get_rect()

        # 每个外星人最初都在屏幕左上角附近
        self.rect.x = self.rect.width
        self.rect.y = self.rect.height   

        # 同子弹一样处理 先在初始位置绘制 再设置准确位置
        # 存储外星人的准确位置
        self.x = float(self.rect.x)   

    def blitme(self):
        """在指定位置绘制外星人"""
        self.screen.blit(self.image, self.rect) 

    def update(self):
        """向右或向左移动外星人"""
        self.x += (self.ai_settings.alien_speed_factor *self.ai_settings.fleet_direction)  #-1表示向左移
        self.rect.x = self.x

    def check_edges(self):
        """如果外星人位于屏幕边缘， 就返回True"""
        screen_rect = self.screen.get_rect()
        if self.rect.right >= screen_rect.right:
            return True
        elif self.rect.left <= 0:
            return True

alien_invasion.py

# 导入了模块sys 和pygame
import sys

# 模块pygame 包含开发游戏所需的功能
import pygame

# 导入设置
from settings import Settings

# 导入飞船
from ship import Ship

# # 导入 Alien
# from alien import Alien

# 导入功能函数模块 在模块game_functions 而不是run_game() 中完成大部分工作。
import game_functions as gf

# pygame.sprite.Group 类类似于列表，但提供了有助于开发游戏的额外功能
# 用于存储所有有效的子弹， 以便能够管理发射出去的所有子弹。
from pygame.sprite import Group

# 导入 GameStats 跟踪游戏统计信息
from game_stats import GameStats

# 导入按钮
from button import Button

# 导入Scoreboard 用于 创建记分牌
from scoreboard import Scoreboard

# pygame 文档 https://www.pygame.org/docs/ref/pygame.html


def run_game():
    # 初始化游戏并创建一个屏幕对象
    pygame.init()  # ide 可能会误报 不存在
    ai_settings = Settings()  # 设置
    screen = pygame.display.set_mode(
        (ai_settings.screen_width, ai_settings.screen_height))  # 屏幕大小  默认创建一个黑色屏幕

    pygame.display.set_caption("Alien Invasion")

    # 创建Play按钮
    play_button = Button(ai_settings, screen, "Play")

    # 创建一个用于存储游戏统计信息的实例
    stats = GameStats(ai_settings)

    # 创建一个Scoreboard 实例
    sb = Scoreboard(ai_settings, screen, stats)

    # 创建一艘飞船
    ship = Ship(ai_settings, screen)  # 入参 包括屏幕 和 设置 信息

    # 创建一个用于存储子弹的编组
    # 创建了一个Group 实例， 并将其命名为bullets 。 这个编组是在while 循环外面创建的， 这样就无需每次运行该循环时都创建一个新的子弹
    bullets = Group()
    aliens = Group()
    # # 创建一个外星人
    # alien = Alien(ai_settings, screen)
    # 创建外星人群
    gf.create_fleet(ai_settings, screen, ship,aliens)

    # 开始游戏的主循环
    while True:

        # 监视键盘鼠标事件
        gf.check_events(ai_settings, screen, stats, sb, play_button, ship,aliens, bullets)

        # 仅在游戏处于活动状态时才运行
        if stats.game_active:
            # 每次执行循环时都调用飞船的方法update() 根据标志 更新飞船位置 通过绘制实现移动
            ship.update()
            # 子弹更新
            gf.update_bullets(ai_settings, screen, stats, sb, ship,aliens, bullets)

            print(len(bullets))

            # 更新每个外星人的位置
            gf.update_aliens(ai_settings, screen, stats, sb, ship, aliens,bullets)
        # 绘制更新屏幕
        gf.update_screen(ai_settings, screen, stats, sb, ship, aliens,bullets, play_button)


run_game()

bullet.py

import pygame
from pygame.sprite import Sprite


class Bullet(Sprite):
    """一个对飞船发射的子弹进行管理的类"""

    def __init__(self, ai_settings, screen, ship):
        """在飞船所处的位置创建一个子弹对象"""
        # 了解 super 可参见  https://www.jianshu.com/p/6b79d13fcff5
        super(Bullet, self).__init__()  # 在super机制里可以保证公共父类仅被执行一次
        self.screen = screen

        # 在(0,0)处创建一个表示子弹的矩形， 再设置正确的位置
        # 子弹并非基于图像的， 因此我们必须使用pygame.Rect() 类从空白开始创建一个矩形。
        self.rect = pygame.Rect(
            0, 0, ai_settings.bullet_width, ai_settings.bullet_height)
        # 正确的位置
        self.rect.centerx = ship.rect.centerx
        self.rect.top = ship.rect.top
        # 存储用小数表示的子弹位置
        self.y = float(self.rect.y)

        self.color = ai_settings.bullet_color
        self.speed_factor = ai_settings.bullet_speed_factor

    # 位置更新
    def update(self):
        """向上移动子弹"""
        # 更新表示子弹位置的小数值
        self.y -= self.speed_factor
        # 更新表示子弹的rect的位置
        self.rect.y = self.y
    # 绘制子弹
    def draw_bullet(self):
        """在屏幕上绘制子弹"""
        pygame.draw.rect(self.screen, self.color, self.rect)

button.py

# 导入了模块pygame.font ， 它让Pygame能够将文本渲染到屏幕上
import pygame.font


class Button():
    def __init__(self, ai_settings, screen, msg):
        """初始化按钮的属性"""
        self.screen = screen
        self.screen_rect = screen.get_rect()
        # 设置按钮的尺寸和其他属性
        self.width, self.height = 200, 50
        self.button_color = (0, 255, 0)
        self.text_color = (255, 255, 255)
        self.font = pygame.font.SysFont(None, 48)
        # 创建按钮的rect对象， 并使其居中
        self.rect = pygame.Rect(0, 0, self.width, self.height)
        self.rect.center = self.screen_rect.center
        # 按钮的标签只需创建一次
        self.prep_msg(msg)

    def prep_msg(self, msg):
        """将msg渲染为图像， 并使其在按钮上居中"""
        # 调用font.render() 将存储在msg 中的文本转换为图像， 然后将该图像存储在msg_image 中
        self.msg_image = self.font.render(
            msg, True, self.text_color, self.button_color)
        self.msg_image_rect = self.msg_image.get_rect()
        self.msg_image_rect.center = self.rect.center

    # 创建方法draw_button() ， 通过调用它可将这个按钮显示到屏幕上
    def draw_button(self):
        # 绘制一个用颜色填充的按钮， 再绘制文本
        self.screen.fill(self.button_color, self.rect)
        self.screen.blit(self.msg_image, self.msg_image_rect)

game_functions.py

此部分过多点击下面链接查看 https://github.com/lichangke/Python3_Project/blob/master/alien_invasion/game_functions.py

game_stats.py

#在这个游戏运行期间， 我们只创建一个GameStats 实例， 但每当玩家开始新游戏时， 需要重置一些统计信息。
#我们在方法reset_stats() 中初始化大部分统计信息，而不是在__init__() 中直接初始化它们。 
class GameStats():
    """跟踪游戏的统计信息"""

    def __init__(self, ai_settings):
        """初始化统计信息"""
        self.ai_settings = ai_settings
        self.reset_stats()
        # 让游戏一开始处于非活动状态 单击Play按钮来开始游戏
        self.game_active = False

        # 在任何情况下都不应重置最高得分
        self.high_score = 0


    def reset_stats(self):
        """初始化在游戏运行期间可能变化的统计信息"""
        self.ships_left = self.ai_settings.ship_limit
        self.score = 0
        self.level = 1

scoreboard.py

import pygame.font
from ship import Ship
from pygame.sprite import Group


class Scoreboard():
    """显示得分信息的类"""

    def __init__(self, ai_settings, screen, stats):
        """初始化显示得分涉及的属性"""
        self.screen = screen
        self.screen_rect = screen.get_rect()
        self.ai_settings = ai_settings
        self.stats = stats

        # 显示得分信息时使用的字体设置
        self.text_color = (30, 30, 30)
        self.font = pygame.font.SysFont(None, 48)

        # 准备包含最高得分和当前得分的图像
        self.prep_score()
        self.prep_high_score()
        self.prep_level()  # 当前等级
        self.prep_ships()  # 剩余飞船

    def prep_score(self):
        """将得分转换为一幅渲染的图像"""
        rounded_score = int(round(self.stats.score, -1))  # 将得分显示为10的整数倍
        # score_str = str(self.stats.score)  # 首先将数字值stats.score 转换为字符串
        score_str = "{:,}".format(rounded_score)
        self.score_image = self.font.render(
            score_str, True, self.text_color, self.ai_settings.bg_color)

        # 将得分放在屏幕右上角
        self.score_rect = self.score_image.get_rect()
        self.score_rect.right = self.screen_rect.right - 20
        self.score_rect.top = 20

    # 显示渲染好的得分图像
    def show_score(self):
        """在屏幕上显示当前得分和最高得分"""
        self.screen.blit(self.score_image, self.score_rect)
        self.screen.blit(self.high_score_image, self.high_score_rect)
        self.screen.blit(self.level_image, self.level_rect)
        # 绘制飞船
        self.ships.draw(self.screen)

    def prep_high_score(self):
        """将最高得分转换为渲染的图像"""
        high_score = int(round(self.stats.high_score, -1))
        high_score_str = "{:,}".format(high_score)
        self.high_score_image = self.font.render(high_score_str, True,
                                                 self.text_color, self.ai_settings.bg_color)
        # 将最高得分放在屏幕顶部中央
        self.high_score_rect = self.high_score_image.get_rect()
        self.high_score_rect.centerx = self.screen_rect.centerx
        self.high_score_rect.top = self.score_rect.top

    def prep_level(self):
        """将等级转换为渲染的图像"""
        self.level_image = self.font.render(
            str(self.stats.level), True, self.text_color, self.ai_settings.bg_color)
        # 将等级放在得分下方
        self.level_rect = self.level_image.get_rect()
        self.level_rect.right = self.score_rect.right
        self.level_rect.top = self.score_rect.bottom + 10

    def prep_ships(self):
        """显示还余下多少艘飞船"""
        self.ships = Group()
        for ship_number in range(self.stats.ships_left):
            ship = Ship(self.ai_settings, self.screen)
            ship.rect.x = 10 + ship_number * ship.rect.width
            ship.rect.y = 10
            self.ships.add(ship)

settings.py

class Settings():
    """存储《外星人入侵》 的所有设置的类"""

    def __init__(self):
        """初始化游戏的设置"""
        # 屏幕设置
        self.screen_width = 1200
        self.screen_height = 800
        self.bg_color = (230, 230, 230)

        # 飞船的设置
        self.ship_speed_factor = 1.5  # 速度
        self.ship_limit = 3

        # 子弹设置
        self.bullet_speed_factor = 3
        self.bullet_width = 3
        self.bullet_height = 15
        self.bullet_color = 60, 60, 60
        self.bullets_allowed = 3  # 限制子弹数目

        # 外星人设置
        self.alien_speed_factor = 1
        self.fleet_drop_speed = 10  # fleet_drop_speed 指定了有外星人撞到屏幕边缘时， 外星人群向下移动的速度
        # fleet_direction为1表示向右移， 为-1表示向左移
        self.fleet_direction = 1
        # 记分
        self.alien_points = 50

        # 以什么样的速度加快游戏节奏
        self.speedup_scale = 1.1
        # 外星人点数的提高速度
        self.score_scale = 1.5
        self.initialize_dynamic_settings()  # 设置speedup_scale ， 用于控制游戏节奏的加快速度2 表示玩家每提高一个等级， 游戏的节奏就翻倍； 1表示游戏节奏始终不变。

    def initialize_dynamic_settings(self):
        """初始化随游戏进行而变化的设置"""
        self.ship_speed_factor = 1.5
        self.bullet_speed_factor = 3
        self.alien_speed_factor = 1
        # fleet_direction为1表示向右； 为-1表示向左
        self.fleet_direction = 1

    def increase_speed(self):
        """提高速度设置"""
        self.ship_speed_factor *= self.speedup_scale
        self.bullet_speed_factor *= self.speedup_scale
        self.alien_speed_factor *= self.speedup_scale
        self.alien_points = int(self.alien_points * self.score_scale)
        print(self.alien_points)

ship.py

import pygame
from pygame.sprite import Sprite

class Ship(Sprite):
    def __init__(self, ai_settings,screen):
        """初始化飞船并设置其初始位置"""
        super(Ship, self).__init__()
        
        self.screen = screen  # 屏幕数据
        self.ai_settings = ai_settings  # 设置
        # 加载飞船图像并获取其外接矩形
        self.image = pygame.image.load('images/ship.bmp')
        self.rect = self.image.get_rect()
        self.screen_rect = screen.get_rect()
        # 将每艘新飞船放在屏幕底部中央
        # 在Pygame中， 原点(0, 0)位于屏幕左上角， 向右下方移动时， 坐标值将增大
        self.rect.centerx = self.screen_rect.centerx  #每次飞船移动 只是 rect.centerx 改变  rect.bottom 不变
        self.rect.bottom = self.screen_rect.bottom
        # 在飞船的属性center中存储小数值
        self.center = float(self.rect.centerx)

        # 移动标志  玩家按住右箭头键不放时， 我们希望飞船不断地向右移动， 直到玩家松开为止 让游戏检测pygame.KEYUP 事件然
        # 后， 我们将结合使用KEYDOWN 和KEYUP 事件， 以及一个名为moving_right 的标志来实现持续移动
        self.moving_right = False
        self.moving_left = False

    def update(self):
        """根据移动标志调整飞船的位置"""
        # 更新飞船的center值， 而不是rect
        if self.moving_right and self.rect.right < self.screen_rect.right: # 限制右边界
            self.center += self.ai_settings.ship_speed_factor
        if self.moving_left and self.rect.left > 0: # 限制左边界
            self.center -= self.ai_settings.ship_speed_factor

        # 根据self.center更新rect对象
        self.rect.centerx = self.center  #self.rect.centerx 将只存储self.center 的整数部分， 但对显示飞船而言， 这问题不大

    def blitme(self):
        """在指定位置绘制飞船"""
        self.screen.blit(self.image, self.rect)

    def center_ship(self):
        """让飞船在屏幕上居中"""
        self.center = self.screen_rect.centerx

GitHub链接： https://github.com/lichangke/LeetCode

知乎个人首页： https://www.zhihu.com/people/lichangke/

简书个人首页： https://www.jianshu.com/u/3e95c7555dc7

个人Blog: https://lichangke.github.io/

欢迎大家来一起交流学习

Read All

每个开发人员都应该知道面向对象设计的原则-(SOLID-Principles-every-Developer-Should-Know).md

2019-03-31

leacoder

Blog

S: 单一职责原则 Single Responsibility Principle
O: 开闭原则原则 Open-Closed Principle
L: 里氏替换原则 Liskov Substitution Principle
I: 接口隔离原则 Interface Segregation Principle
D: 依赖倒置原则 Dependency Inversion Principle

左耳听风第二周 Review.png

原文：SOLID Principles every Developer Should Know 原作者：Chidume Nnamdi

第一次看到SOLID 原则，是在http://www.runoob.com/学习设计模式时想了解设计模式（Design pattern）点击链接设计模式

每个开发人员都应知道的 SOLID 原则。作者通过简单代码示例，介绍了SLOID原则。面向对象的编程并不能防止难以理解或不可维护的程序。因此，Robert C. Martin 制定了五项指导原则，使开发人员很容易创建出可读性强且可维护的程序。这五个原则被称为S.O.L.I.D原则(首字母缩写是迈克尔·费瑟[Michael Feathers]提出的)。

S: 单一职责原则 Single Responsibility Principle 一个类应该只负责一件事
O: 开闭原则原则 Open-Closed Principle 软件实体（类，模块，函数）应该是可以扩展的，而不是修改。
L: 里氏替换原则 Liskov Substitution Principle 任何基类可以出现的地方，子类一定可以出现
I: 接口隔离原则 Interface Segregation Principle 创建特定于客户端的细粒度接口 不强制客户端依赖他们不使用的接口。
D: 依赖倒置原则 Dependency Inversion Principle 依赖关系应该是抽象的，而不是具体的。 A. 高级模块不应该依赖于低级模块。两者都应该依赖于抽象。 B. 抽象不应该依赖于细节。细节应该依赖于抽象。

S: 单一职责原则 Single Responsibility Principle

一个类应该只负责一件事。如果一个类有多个职责，它就会耦合。对一个职责的更改会导致对另一个职责的更改。

class Animal {
    constructor(name: string){ }
    getAnimalName() { }
    saveAnimal(a: Animal) { }
}

Animal类违反了单一职责原则（SRP）。 SRP声明类应该只有一个职责，在这个类里，我们可以看到有两个职责：Animal数据管理和动物属性管理。这个类的构造函数和getAnimalName方法管理Animal的属性，而saveAnimal方法管理Animal的数据存储。这个设计在以后会引起什么样的问题? 如果应用的更改影响到了数据库的操作，那么使用Animal属性的类必须做相应的修改。这个系统缺乏弹性，就像多米诺骨牌效应，触摸一张牌就会影响到其他所有的牌。为了符合SRP，我们创建了另一个类，它的职责是存储animal到数据库:

class Animal {  
    constructor(name: string){ }  
    getAnimalName() { }  
}

class AnimalDB {  
    getAnimal(a: Animal) { }  
    saveAnimal(a: Animal) { }  
}

当我们在设计类时，应该把特性相关的放在一起。同时，我们应该把特性不同的分开。-史蒂夫芬頓

O: 开闭原则原则 Open-Closed Principle

软件实体（类，模块，函数）应该是可以扩展的，而不是修改。

class Animal {  
    constructor(name: string){ }  
    getAnimalName() { }  
}
//我们想要遍历动物列表并设置它们的声音。
const animals: Array<Animal> = [  
    new Animal('lion'),  
    new Animal('mouse')  
];

function AnimalSound(a: Array<Animal>) {  
    for(int i = 0; i <= a.length; i++) {  
        if(a[i].name == 'lion')  
            log('roar');  
        if(a[i].name == 'mouse')  
            log('squeak');  
    }  
}  
AnimalSound(animals);

AnimalSound方法不符合开闭原则，因为有新动物出现时，需要修改AnimalSound方法

我们如何使它(AnimalSound方法)遵循OCP?

class Animal {  
        makeSound();  
        ...  
}

class Lion extends Animal {  
    makeSound() {  
        return 'roar';  
    }  
}

class Squirrel extends Animal {  
    makeSound() {  
        return 'squeak';  
    }  
}  
class Snake extends Animal {  
    makeSound() {  
        return 'hiss';  
    }  
}

...  
function AnimalSound(a: Array<Animal>) {  
    for(int i = 0; i <= a.length; i++) {  
        log(a[i].makeSound());  
    }  
}  
AnimalSound(animals);

L: 里氏替换原则 Liskov Substitution Principle

任何基类可以出现的地方，子类一定可以出现

function AnimalLegCount(a: Array<Animal>) {
    for(int i = 0; i <= a.length; i++) {
        if(typeof a[i] == Lion)
            log(LionLegCount(a[i]));
        if(typeof a[i] == Mouse)
            log(MouseLegCount(a[i]));
        if(typeof a[i] == Snake)
            log(SnakeLegCount(a[i]));
    }
}
AnimalLegCount(animals);

这违反了LSP原则(以及OCP原则)。它必须知道每种Animal类型，并调用相应的leg-counting方法。

现在，我们可以重新实现下AnimalLegCount方法

function AnimalLegCount(a: Array<Animal>) {  
    for(let i = 0; i <= a.length; i++) {  
        a[i].LegCount();  
    }  
}  
AnimalLegCount(animals);
/*
AnimalLegCount方法不用关心参数Animal的类型，它只是去调用LegCount方法。它只要求参数必须为Animal类型，要么是Animal类，要么是它的子类。
*/
//现在，Animal类必须实现或者定义一个LegCount方法：
class Animal {  
    ...  
    LegCount();  
}
//而它的子类必须实现LegCount方法：
//...
class Lion extends Animal{
    //...
    LegCount() {
        //...
    }
}
//...

当在AnimalLegCount方法中调用时，会返回lion的腿数。 AnimalLegCount方法在不需要知道Animal类型的情况下，只调用每个Animal的LegCount方法，来获得Animal的腿数，因为根据约定，Animal的子类实现了LegCount方法。

I: 接口隔离原则 Interface Segregation Principle

interface IShape {  
    drawCircle();  
    drawSquare();  
    drawRectangle();  
}
//这个接口绘制正方形、圆形和矩形。实现IShape接口的类必须定义drawCircle, drawSquare, drawRectangle方法。
class Circle implements IShape {
    drawCircle(){
        //...
    }
    drawSquare(){
        //...
    }
    drawRectangle(){
        //...
    }    
}
class Square implements IShape {
    drawCircle(){
        //...
    }
    drawSquare(){
        //...
    }
    drawRectangle(){
        //...
    }    
}
class Rectangle implements IShape {
    drawCircle(){
        //...
    }
    drawSquare(){
        //...
    }
    drawRectangle(){
        //...
    }    
}

Rectangle类实现了它不使用的方法(drawCircle和drawSquare) ，同样，Square类实现了drawCircle和drawRectangle方法，Square类实现了drawSquare和drawSquare方法。如果我们需要在IShape接口中添加另外一个方法drawTriangle，

interface IShape {  
    drawCircle();  
    drawSquare();  
    drawRectangle();  
    drawTriangle();  
}

类必须实现新的方法，否则会抛出错误。

为了让我们的IShape接口遵循ISP原则，我们将不同的操作隔离到不同的接口上：

interface IShape {  
    draw();  
}

interface ICircle {  
    drawCircle();  
}

interface ISquare {  
    drawSquare();  
}

interface IRectangle {  
    drawRectangle();  
}

interface ITriangle {  
    drawTriangle();  
}

class Circle implements ICircle {  
    drawCircle() {  
        ...  
    }  
}

class Square implements ISquare {  
    drawSquare() {  
        ...  
    }  
}

class Rectangle implements IRectangle {  
    drawRectangle() {  
        ...  
    }      
}

class Triangle implements ITriangle {  
    drawTriangle() {  
        ...  
    }  
}  
class CustomShape implements IShape {  
   draw(){  
      ...  
   }  
}

ICircle接口只绘制圆，IShape接口绘制任意形状，ISquare接口只绘制正方形，IRectangle接口只绘制矩形。或者类（Circle、Rectangle、Square、Triangle等）只继承IShape接口，并且实现它们自己的绘画行为。

class Circle implements IShape {
    draw(){
        //...
    }
}

class Triangle implements IShape {
    draw(){
        //...
    }
}

class Square implements IShape {
    draw(){
        //...
    }
}

class Rectangle implements IShape {
    draw(){
        //...
    }
}      

D: 依赖倒置原则 Dependency Inversion Principle

class XMLHttpService extends XMLHttpRequestService {}

class Http {  
    constructor(private xmlhttpService: XMLHttpService) { }  
    get(url: string , options: any) {  
        this.xmlhttpService.request(url,'GET');  
    }

    post() {  
        this.xmlhttpService.request(url,'POST');  
    }  
    //...  
}

Http是高级组件，而HttpService是低级组件。这种设计违反了DIP A：高级模块不应该依赖于低级模块。它应该依赖它的抽象。这个Http类被强制依赖XMLHttpService类。如果我们要更改Http连接服务，可能需要通过Nodejs连接到互联网，或者模拟http服务。我们将必须修改每个Http实例，这违背了OCP原则。

/*
Http类应该更少的去关心你用的Http服务类型。
让我们来实现一个Connection接口：
*/
interface Connection {  
    request(url: string, opts:any);  
}
//Connection这个接口有一个request方法。有了这个接口，我们可以给我们的Http类传入一个Connection类型的参数：
class Http {  
    constructor(private httpConnection: Connection) { }

    get(url: string , options: any) {  
        this.httpConnection.request(url,'GET');  
    }

    post() {  
        this.httpConnection.request(url,'POST');  
    }  
    //...  
}
//现在，不管给Http类传入什么类型的Http服务连接参数，在不用关心网络连接类型的情况下，连接到网络也是很容易的。
//我们可以重新实现下我们的XMLHttpService类，来实现Connection接口：
class XMLHttpService implements Connection {  
    const xhr = new XMLHttpRequest();  
   // ...  
    request(url: string, opts:any) {  
        xhr.open();  
        xhr.send();  
    }  
}
//我们可以创建许多Http Connection类型，并将其传递给我们的Http类，而无需担心错误。
class NodeHttpService implements Connection {  
    request(url: string, opts:any) {  
        ...  
    }  
}

class MockHttpService implements Connection {  
    request(url: string, opts:any) {  
        ...  
    }      
}

现在，我们可以看到高级模块和低级模块都依赖于抽象。Http类（高级模块）依赖于Connection接口（抽象），而Http服务类型（低级模块）也依赖Connection接口（抽象）。

GitHub链接： https://github.com/lichangke/LeetCode

知乎个人首页： https://www.zhihu.com/people/lichangke/

简书个人首页： https://www.jianshu.com/u/3e95c7555dc7

个人Blog: https://lichangke.github.io/

欢迎大家来一起交流学习

Read All

LeetCode-22--括号生成(Generate-Parentheses)

2019-03-31

leacoder

Algorithm

Algorithm Leetcode

22. 括号生成
Python3实现
- 递归

22. 括号生成

给出 n 代表生成括号的对数，请你写出一个函数，使其能够生成所有可能的并且有效的括号组合。

例如，给出 n = 3，生成结果为：

[
  "((()))",
  "(()())",
  "(())()",
  "()(())",
  "()()()"
]

Python3实现

递归

# @author:leacoder 
# @des:   递归 括号生成  
class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        self.list = []
        self.fnrecursive(0,0,n,"")
        return self.list
    
   
    #left："("左括号被使用次数  right:")"右括号被使用次数 n:可以被使用括号对数  result：有效括号结果
    def fnrecursive(self,left,right,n,result):
        if left == n and right == n: # 左右括号使用次数均到达n次
            self.list.append(result)
            return
        # 1、要使括号有效 ，那么我们最先放的是 左括号 ，需要满足left < n
        if left < n:
            self.fnrecursive(left+1,right,n,result + "(")
        # 2、要使括号有效 ，右括号使用次数必然不大于左括号，并且 right < n
        if left > right and right < n: 
            self.fnrecursive(left,right+1,n,result + ")")

GitHub链接： https://github.com/lichangke/LeetCode

知乎个人首页： https://www.zhihu.com/people/lichangke/

简书个人首页： https://www.jianshu.com/u/3e95c7555dc7

个人Blog: https://lichangke.github.io/

欢迎大家来一起交流学习

Read All

LeetCode-111--二叉树的最小深度(Minimum-Depth-of-Binary-Tree)

2019-03-31

leacoder

Algorithm

Algorithm Leetcode

111. 二叉树的最小深度
Python3实现
- DFS 深度优先
- BFS广度优先

111. 二叉树的最小深度

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明: 叶子节点是指没有子节点的节点。

示例:

给定二叉树 [3,9,20,null,null,15,7],

返回它的最小深度 2.

Python3实现

DFS 深度优先

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
# @author:leacoder 
# @des:  DFS 深度优先  二叉树的最大深度  时间复杂度 O(n)

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root: 
            return 0  #入参校验
        else: # DFS
            leftlevel = self.maxDepth(root.left) #  递归 左子树 得到其深度
            rightlevel = self.maxDepth(root.right) #  递归 右子树 得到其深度
            return 1 + max(leftlevel,rightlevel) # 取最大深度 

BFS广度优先

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
# @author:leacoder 
# @des:  BFS 广度优先  二叉树的最大深度  时间复杂度 O(n)

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root: 
            return 0  #入参校验
        else: # BFS
            queue = collections.deque()
            queue.append(root) # 辅助队列
            maxlevel = 0 #层级记录
            while queue:
                levelsize = len(queue) #
                for i in range(levelsize): 
                    node = queue.popleft()
                    if node.left:
                        queue.append(node.left)
                    if node.right:
                        queue.append(node.right)
                maxlevel +=1 # 广度优先搜索 每层搜完 层级+1
            
            return maxlevel

GitHub链接： https://github.com/lichangke/LeetCode

知乎个人首页： https://www.zhihu.com/people/lichangke/

简书个人首页： https://www.jianshu.com/u/3e95c7555dc7

个人Blog: https://lichangke.github.io/

欢迎大家来一起交流学习

Read All

LeetCode-104--二叉树的最大深度(Maximum-Depth-of-Binary-Tree)

2019-03-31

leacoder

Algorithm

Algorithm Leetcode

104. 二叉树的最大深度
Python3实现
- DFS深度优先
- BFS广度优先

104. 二叉树的最大深度

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：

给定二叉树 [3,9,20,null,null,15,7]，

返回它的最大深度 3 。

Python3实现

DFS深度优先

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
# @author:leacoder 
# @des:  DFS 深度优先  二叉树的最大深度  时间复杂度 O(n)

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root: 
            return 0  #入参校验
        else: # DFS
            leftlevel = self.maxDepth(root.left) #  递归 左子树 得到其深度
            rightlevel = self.maxDepth(root.right) #  递归 右子树 得到其深度
            return 1 + max(leftlevel,rightlevel) # 取最大深度 

BFS广度优先

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
# @author:leacoder 
# @des:  BFS 广度优先  二叉树的最大深度  时间复杂度 O(n)

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root: 
            return 0  #入参校验
        else: # BFS
            queue = collections.deque()
            queue.append(root) # 辅助队列
            maxlevel = 0 #层级记录
            while queue:
                levelsize = len(queue) #
                for i in range(levelsize): 
                    node = queue.popleft()
                    if node.left:
                        queue.append(node.left)
                    if node.right:
                        queue.append(node.right)
                maxlevel +=1 # 广度优先搜索 每层搜完 层级+1
            
            return maxlevel

GitHub链接： https://github.com/lichangke/LeetCode

知乎个人首页： https://www.zhihu.com/people/lichangke/

简书个人首页： https://www.jianshu.com/u/3e95c7555dc7

个人Blog: https://lichangke.github.io/

欢迎大家来一起交流学习

Read All

VMWare虚拟机通过主机代理上网

2019-03-30

leacoder

Linux

Linux
1.在宿主机windows上运行shadowsocks.exe并勾选“允许其他设备连接”

2.设置网络连接

3.查询主机IP

4.进入虚拟机linux系统，设置网络

System Settings – Network – Network proxy勾选Manual（手动）,地址全部填宿主机IP（局域网网段），设置好代理端口（可在windows下的shadowsocks查看，一般为默认1080）

5.可能浏览器也需要设置（Firefox）

GitHub链接： https://github.com/lichangke/LeetCode

知乎个人首页： https://www.zhihu.com/people/lichangke/

简书个人首页： https://www.jianshu.com/u/3e95c7555dc7

个人Blog: https://lichangke.github.io/

欢迎大家来一起交流学习
Read All

7/12

Welcome to LeaCoder's Blog!

开发系统和开发IDE

资料《Python编程从入门到实践》书籍

相关问题以及解决

相关第三方库

GitHub:

目录文件结构

运行与效果

alien.py

alien_invasion.py

bullet.py

button.py

game_functions.py

game_stats.py

scoreboard.py

settings.py

ship.py

S: 单一职责原则 Single Responsibility Principle

O: 开闭原则原则 Open-Closed Principle

L: 里氏替换原则 Liskov Substitution Principle

I: 接口隔离原则 Interface Segregation Principle

D: 依赖倒置原则 Dependency Inversion Principle

Python3实现

递归

Python3实现

DFS 深度优先

BFS广度优先

Python3实现

DFS深度优先

BFS广度优先

1.在宿主机windows上运行shadowsocks.exe并勾选“允许其他设备连接”

2.设置网络连接

3.查询主机IP

4.进入虚拟机linux系统，设置网络

5.可能浏览器也需要设置（Firefox）