在Python中的if系列条件语句的一般形式如下所示:(注意一点，python的缩进，python是通过缩进表示同一代码块）
 
if  condition_1: 
         statement_block_1  
#注意因为python中代码块不像Java等语言使用{}来约束范围，而是使用tab缩进来表示同一个代码块。
elif  condition_2:
        statement_block_2
else: 
        statement_block_3

如果 "condition_1" 为 True 将执行 "statement_block_1" 块语句
如果 "condition_1" 为False，将判断 "condition_2"
如果"condition_2" 为 True 将执行 "statement_block_2" 块语句
如果 "condition_2" 为False，将执行"statement_block_3"块语句
Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else，中间elif可以有多个。

注意：
1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块，只要是同一个缩进数即可，不建议用tab。
3.if-else,if ,if-elif-else可以嵌套使用
4.if可以单独使用，if-else可以一起使用，if-elif可以一起使用(可以没有else)
  if-elif-else可以一起使用，但是elif必须和if一起使用，不能一起使用。
4、在Python中没有switch – case语句。
5.注意if的条件只要是能返回单个布尔值的表达式即可，可以是任何表达式，任何非零、或非空（null）的值均为true。
 
案例演示如下：
 
1.测试if-elif-else条件语句的代码如下：

#coding=utf-8
score = input("请输入考试分数：")
if int(score) >90 :  #下面两个都是tab缩进，默认一个代码块。
    print ("excellent!")
    print("you  got the best score >90")
 #print("这是缩进测试") #如果在这里随便写一个缩进的话 ，会报错，因为if后面只能跟一个代码块。
elif int(score) >=70 :
    print("good")
    print("you got the good socre 70-90")
elif int(score) >=60 : #注意：下面这两个输出都是5个空格填充，统一缩进，也是默认同一代码块。
          print ("not bad")
          print("you got the so-so score 60-70")
else :
    print("bad socre")
    print ("you ")
print("game over!")  #只要跟最后一个else不是统一代码块的，都算条件外的代码，都会执行。
  #print("hahah") #这样写，肯定报错，因为只要不是条件里的代码块，python要求必须顶格书写代码。

执行结果如下：
请输入考试分数：90
good
you got the good socre 70-90
game over!
-----------------------------
请输入考试分数：60
not bad
you got the so-so score 60-70
game over!

-------------------------------------------------------------------------
2.if条件语句嵌套使用演示：注意这里子代码块的缩进
-------------------------------------------------------------------------
#coding=utf-8
chePiao = 1  # 用1代表有车票，0代表没有车票
daoLenght = 9  # 刀子的长度，单位为cm

if chePiao == 1:
    print("有车票，可以进站")
    if daoLenght < 10:
        print("通过安检")
        print("终于可以见到Ta了，美滋滋~~~")
    else:
        print("没有通过安检")
        print("刀子的长度超过规定，等待警察处理...")
else:
    print("没有车票，不能进站")
    print("亲爱的，那就下次见了，一票难求啊~~~~(>_<)~~~~")
--------------------------------
代码演示结果：
结果1：chePiao = 1;daoLenght = 20

    有车票，可以进站
    没有通过安检
    刀子的长度超过规定，等待警察处理...
结果2：chePiao = 0;daoLenght = 9

    没有车票，不能进站
    亲爱的，那就下次见了，一票难求啊~~~~(>_<)~~~~
------------------------------------------------------
3.if语句中多个判断条件时演示（if的条件只要是能返回单个布尔值的表达式即可）
-----------------------------------------------------
num = 9
if num >= 0 and num <= 10:    # 判断值是否在0~10之间
    print 'hello'
# 输出结果: hello
 
num = 10
if num < 0 or num > 10:    # 判断值是否在小于0或大于10
    print 'hello'
else:
    print 'undefine'
# 输出结果: undefine
 
num = 8
# 判断值是否在0~5或者10~15之间
if (num >= 0 and num <= 5) or (num >= 10 and num <= 15):    
    print 'hello'
else:
    print 'undefine'
# 输出结果: undefine
 
统一声明：关于原创博客内容，可能会有部分内容参考自互联网，如有原创链接会声明引用；如找不到原创链接，在此声明如有侵权请联系删除哈。关于转载博客，如有原创链接会声明；如找不到原创链接，在此声明如有侵权请联系删除哈。

在开发中我们经常会碰到有些场景，需要根据某个字段的不同含义，去执行不同的逻辑操作，一般我们会倾向于使用if/else或者switch/case的方式，但当字段的含义不断增加，或者各种含义情况都需要执行非常多逻辑的时候，使用if/else/switch会使代码不易维护，且可读性差。那么，使用枚举，将是一种非常好的改善方式。
 
举例：当不同角色去审批员工请假单时，执行的逻辑是不一样的，比如直属小组长需要确认员工的工作进度是否正常，工作交接是否正常，而团队负责人要确认总项目进度是否有影响等等。如果使用if/else的方式，我们的代码会是如下这样：
 
public void judge(Long applyId, String role){
        if (role.equals("leader")) {
            //leader doing
        } else if (role.equals("service owner")) {
            //service owner doing
        } else if (role.equals("project manager")) {
            //project manager doing
        } else if (role.equals("supervisor")) {
            //supervisor doing
        } ...
    }
 
后续如果再增加人物角色，会不断增多if/else，有代码洁癖的会很难受。。一旦角色数量达到几十的时候，看代码估计要疯。。非常不利于扩展和维护。
 
接下来我们使用java枚举的方式改造一下。首先定义一个公用接口：
 
public interface RoleService {

    //审批操作，后续增加其他操作只需要再新建方法
    void approve();
}
 
接下来我们定义一个不同角色执行不同逻辑的枚举类 RoleServiceEnum来实现接口，将不同角色的逻辑全部交由这个枚举类来做：
 
public enum RoleServiceEnum implements RoleService {
    ROLE_LEADER(){
        @Override
        public void approve() {
            System.out.println("leader doing sth");
        }
    },

    ROLE_SERVICE_OWNER(){
        @Override
        public void approve() {
            System.out.println("so doing sth");
        }
    },

    ROLE_PROJECT_MANAGER(){
        @Override
        public void approve() {
            System.out.println("pm doing sth");
        }
    },

    ROLE_SUPERVISOR(){
        @Override
        public void approve() {
            System.out.println("supervisor doing sth");
        }
    };
}
 
接下来我们再调用这个枚举类，执行不同角色审批请假单的逻辑，一行代码就行了：
 
    public void judge(String role){
        RoleServiceEnum.valueOf(role).approve();
    }
 
 

在自学Python的过程中在网上查询资料时发现了一些好玩的东西，python的游戏库模块，它可以自己弄一个小游戏来玩玩，然后我在网上找了一些游戏的代码，，自己改了一些，弄出了一个简单贪吃蛇，代码也是照着敲的只是稍微的改了一下
 
import pygame, sys, random, time
from pygame.locals import *  # 从pygame模块导入常用的函数和常量
#定义颜色变量
black_colour = pygame.Color(28, 56, 20)
white_colour = pygame.Color(255, 144, 20)
red_colour = pygame.Color(255,34 , 20)
grey_colour = pygame.Color(150, 150, 150)
#定义游戏结束函数
def GameOver(gamesurface):
    # 设置提示字体的格式
    GameOver_font = pygame.font.SysFont("MicrosoftYaHei", 16)
    # 设置提示字体的颜色
    GameOver_colour = GameOver_font.render('GameOver', True, grey_colour)#只能英文
    # 设置提示位置
    GameOver_location = GameOver_colour.get_rect()
    GameOver_location.midtop = (310, 200)
    # 绑定以上设置到句柄
    gamesurface.blit(GameOver_colour, GameOver_location)
    # 提示运行信息
    pygame.display.flip()
    # 休眠5秒
    time.sleep(5)
    # 退出游戏
    pygame.quit()
    # 退出程序
    sys.exit()
#定义主函数
def main():
    # 初始化pygame，为使用硬件做准备
    pygame.init()
    pygame.time.Clock()
    ftpsClock = pygame.time.Clock()
    # 创建一个窗口
    gamesurface = pygame.display.set_mode((640, 480))
    # 设置窗口的标题
    pygame.display.set_caption('tanchishe snake')
    # 初始化变量
    # 初始化贪吃蛇的起始位置
    snakeposition = [100, 100]
    # 初始化贪吃蛇的长度
    snakelength = [[100, 100], [80, 100], [60, 100]]
    # 初始化目标方块的位置
    square_purpose = [300, 300]
    # 初始化一个数来判断目标方块是否存在
    square_position = 1
    # 初始化方向，用来使贪吃蛇移动
    derection = "right"
    change_derection = derection
    # 进行游戏主循环
    while True:
        # 检测按键等pygame事件
        for event in pygame.event.get():
            if event.type == QUIT:
                # 接收到退出事件后，退出程序
                pygame.quit()
                sys.exit()
            elif event.type == KEYDOWN:
                # 判断键盘事件,用w,s,a,d来表示上下左右
                if event.key == K_RIGHT or event.key == ord('d'):
                    change_derection = "right"
                if event.key == K_LEFT or event.key == ord('a'):
                    change_derection = "left"
                if event.key == K_UP or event.key == ord('w'):
                    change_derection = "up"
                if event.key == K_DOWN or event.key == ord('s'):
                    change_derection = "down"
                if event.key == K_ESCAPE:
                    pygame.event.post(pygame.event.Event(QUIT))
        # 判断移动的方向是否相反
        if change_derection == 'left' and not derection == 'right':
            derection = change_derection
        if change_derection == 'right' and not derection == 'left':
            derection = change_derection
        if change_derection == 'up' and not derection == 'down':
            derection = change_derection
        if change_derection == 'down' and not derection == 'up':
            derection = change_derection
        # 根据方向，改变坐标
        if derection == 'left':
            snakeposition[0] -= 20
        if derection == 'right':
            snakeposition[0] += 20
        if derection == 'up':
            snakeposition[1] -= 20
        if derection == 'down':
            snakeposition[1] += 20
        # 增加蛇的长度
        snakelength.insert(0, list(snakeposition))
        # 判断是否吃掉目标方块
        if snakeposition[0] == square_purpose[0] and snakeposition[1] == square_purpose[1]:
            square_position = 0
        else:
            snakelength.pop()
        # 重新生成目标方块
        if square_position == 0:
            # 随机生成x,y,扩大二十倍，在窗口范围内
            x = random.randrange(1, 32)
            y = random.randrange(1, 24)
            square_purpose = [int(x * 20), int(y * 20)]
            square_position = 1
        # 绘制pygame显示层
        gamesurface.fill(black_colour)
        for position in snakelength:
            pygame.draw.rect(gamesurface, white_colour, Rect(position[0], position[1], 20, 20))
            pygame.draw.rect(gamesurface, red_colour, Rect(square_purpose[0], square_purpose[1], 20, 20))
        # 刷新pygame显示层
        pygame.display.flip()
        # 判断是否死亡
        if snakeposition[0] < 0 or snakeposition[0] > 620:
            GameOver(gamesurface)
        if snakeposition[1] < 0 or snakeposition[1] > 460:
            GameOver(gamesurface)
        for snakebody in snakelength[1:]:
            if snakeposition[0] == snakebody[0] and snakeposition[1] == snakebody[1]:
                GameOver(gamesurface)
        # 控制游戏速度
        ftpsClock.tick(8)
if __name__ == "__main__":
    main()

 
 
if else 是我们写代码时，使用频率最高的关键词之一，然而有时过多的 if else 会让我们感到脑壳疼。
 
例如下面这个伪代码：
 
 
是不是很崩溃？虽然他是伪代码，并且看起来也很夸张，但在现实中，当我们无数次 Review 别人代码时，都会发现类似的场景。
 
 
 
那么我们本文就来详细聊聊，有没有什么方法可以让我们避免来写这么多的 if else 呢？
 
 
 
我们本文提供了 9 种方法来解决掉那些“烦人”的 if else，一起来看吧。
 
 
 
1、使用 return
 
 
 
我们使用 return 去掉多余的 else，实现代码如下。
 
 
 
优化前代码：
 
if ("java".equals(str)) {
    // 业务代码......
} else {
    return;
}
 
 
 
优化后代码：
 
if (!"java".equals(str)) {
    return;
}
// 业务代码......
 
 
 
这样看起来就会舒服很多，虽然相差只有一行代码，但真正的高手和普通人之间的差距就是从这一行行代码中体现出来的。
 
 
 
“勿以善小而不为，勿以恶小而为之”，“千里之堤，溃于蚁穴”，说的都是同样的道理。
 
 
 
2、使用 Map
 
 
 
使用 Map 数组，把相关的判断信息，定义为元素信息可以直接避免 if else 判断，实现代码如下。
 
 
 
优化前代码：
 
if (t == 1) {
    type = "name";
} else if (t == 2) {
    type = "id";
} else if (t == 3) {
    type = "mobile";
}
 
 
 
我们先定义一个 Map 数组，把相关判断信息存储起来：
 
Map<Integer, String> typeMap = new HashMap<>();
typeMap.put(1, "name");
typeMap.put(2, "id");
typeMap.put(3, "mobile");
 
 
 
之前的判断语句可以使用以下一行代码代替了：
 
type = typeMap.get(t);
 
 
 
3、使用三元运算符
 
 
 
三元运算符也叫三元表达式或者三目运算符/表达式，不过代表的都是一个意思，优化代码如下。
 
 
 
优化前代码：
 
Integer score = 81;
if (score > 80) {
    score = 100;
} else {
    score = 60;
}
 
 
 
优化后代码：
 
score = score > 80 ? 100 : 60;
 
 
 
4、合并条件表达式
 
 
 
在项目中有些逻辑判断是可以通过梳理和归纳，变更为更简单易懂的逻辑判断代码，如下所示。
 
 
 
优化前代码：
 
String city = "西安";
String area = "029";
String province = "陕西";
if ("西安".equals(city)) {
    return "xi'an";
}
if ("029".equals(area)) {
    return "xi'an";
}
if ("陕西".equals(province)){
    return "xi'an";
}
 
 
 
优化后代码：
 
if ("西安".equals(city) || "029".equals(area) || "陕西".equals(province)){
    return "xi'an";
}
 
 
 
5、使用枚举
 
 
 
JDK 1.5 中引入了新的类型——枚举（enum），我们使用它可以完成很多功能，例如下面这个。
 
 
 
优化前代码：
 
Integer typeId = 0;
String type = "Name";
if ("Name".equals(type)) {
    typeId = 1;
} else if ("Age".equals(type)) {
    typeId = 2;
} else if ("Address".equals(type)) {
    typeId = 3;
}
 
 
 
优化时，我们先来定义一个枚举：
 
public enum TypeEnum {
    Name(1), Age(2), Address(3);
    public Integer typeId;
    TypeEnum(Integer typeId) {
        this.typeId = typeId;
    }
}
 
 
 
之前的 if else 判断就可以被如下一行代码所替代了：
 
typeId = TypeEnum.valueOf("Name").typeId;
 
 
 
6、使用 Optional
 
 
 
从 JDK 1.8 开始引入 Optional 类，在 JDK 9 时对 Optional 类进行了改进，增加了 ifPresentOrElse() 方法，我们可以借助它，来消除 if else 的判断，使用如下。
 
 
 
优化前代码：
 
String str = "java";
if (str == null) {
    System.out.println("Null");
} else {
    System.out.println(str);
}
 
 
 
优化后代码：
 
Optional<String> opt = Optional.of("java");
opt.ifPresentOrElse(v -> 
    System.out.println(v), () -> System.out.println("Null"));
 
 
 
小贴士：注意运行版本，必须是 JDK 9+ 才行。
 
 
 
7、梳理优化判断逻辑
 
 
 
和第 4 点比较类似，我们可以通过分析 if else 的逻辑判断语义，写出更加易懂的代码，例如以下这个嵌套判断的优化。
 
 
 
优化前代码：
 
// 年龄大于 18
if (age > 18) {
    // 工资大于 5000
    if (salary > 5000) {
        // 是否漂亮
        if (pretty == true) {
            return true;
        }
    }
}
return false;
 
 
 
优化后代码：
 
if (age < 18) {
    return false;
}
if (salary < 5000) {
    return false;
}
return pretty; 
 
 
 
我们需要尽量把表达式中的包含关系改为平行关系，这样代码可读性更高，逻辑更清晰。
 
 
 
8、使用多态
 
 
 
继承、封装和多态是 OOP（面向对象编程）的重要思想，本文我们使用多态的思想，提供一种去除 if else 方法。
 
 
 
优化前代码：
 
Integer typeId = 0;
String type = "Name";
if ("Name".equals(type)) {
    typeId = 1;
} else if ("Age".equals(type)) {
    typeId = 2;
} else if ("Address".equals(type)) {
    typeId = 3;
}
 
 
 
使用多态，我们先定义一个接口，在接口中声明一个公共返回 typeId 的方法，在添加三个子类分别实现这三个子类。
 
 
 
实现代码如下：
 
public interface IType {
    public Integer getType();
}

public class Name implements IType {
    @Override
    public Integer getType() {
        return 1;
    }
}

public class Age implements IType {
    @Override
    public Integer getType() {
        return 2;
    }
}

public class Address implements IType {
    @Override
    public Integer getType() {
        return 3;
    }
}
 
 
 
注意：为了简便我们这里把类和接口放到了一个代码块中，在实际开发中应该分别创建一个接口和三个类分别存储。
 
 
 
此时，我们之前的 if else 判断就可以改为如下代码：
 
IType itype = (IType) Class.forName("com.example." + type).newInstance();
Integer typeId = itype.getType();
 
 
 
有人可能会说，这样反而让代码更加复杂了，此可谓“杀鸡焉用宰牛刀”的典型范例了。
 
 
 
这里作者只是提供一种实现思路和提供了一些简易版的代码，以供开发者在实际开发中，多一种思路和选择，具体用不用需要根据实际情况来定了。灵活变通，举一反三，才是开发的上乘心法。
 
 
 
9、选择性的使用 switch
 
 
 
很多人都搞不懂 switch 和 if else 的使用场景，但在两者都能使用的情况下，可以尽量使用 switch，因为 switch 在常量分支选择时，switch 性能会比 if else 高。
 
 
 
if else 判断代码：
 
if ("add".equals(cmd)) {
    result = n1 + n2;
} else if ("subtract".equals(cmd)) {
    result = n1 - n2;
} else if ("multiply".equals(cmd)) {
    result = n1 * n2;
} else if ("divide".equals(cmd)) {
    result = n1 / n2;
} else if ("modulo".equals(cmd)) {
    result = n1 % n2;
}
 
 
 
switch 代码：
 
switch (cmd) {
    case "add":
        result = n1 + n2;
        break;
    case "subtract":
        result = n1 - n2;
        break;
    case "multiply":
        result = n1 * n2;
        break;
    case "divide":
        result = n1 / n2;
        break;
    case "modulo":
        result = n1 % n2;
        break;
}
 
 
 
在 Java 14 可使用 switch 代码块，实现代码如下：
 
// java 14
switch (cmd) {
    case "add" -> {
        result = n1 + n2;
    }
    case "subtract" -> {
        result = n1 - n2;
    }
    case "multiply" -> {
        result = n1 * n2;
    }
    case "divide" -> {
        result = n1 / n2;
    }
    case "modulo" -> {
        result = n1 % n2;
    }
}
 
 
 
10、总结
 
 
 
业精于勤荒于嬉，行成于思毁于随。编程是一门手艺，更是一种乐趣，全身心的投入到自己稍微努力一下就能完成的工作中去！
 
 
 
是啊，太简单的事情通常无法调动起我们的兴趣，而太难的工作又会让我们丧失信心，只有那些看似很难但稍微努力一点就能完成的事情，才会给我们带来巨大的快乐。
 
 
 
我想编程也是一样，普通的方法每个人都会写，然而优雅一点的代码不是所有人都能写得出来，而本文恰恰是提供了写出优雅代码的一些思路，希望可以帮助和启发到你。