python是通过缩进格式来区分不同语句块的。Python语言利用缩进表示语句块的开始和退出（Off-side规则），增加缩进表示语句块的开始，而减少缩进则表示语句块的退出。

Python语句块

1、语句块是在条件为真（条件语句）时执行或者执行多次（循环语句）的一组语句；

2、在代码前放置空格来缩进语句即可创建语句块，语句块中的每行必须是同样的缩进量；

3、缩进：Python开发者有意让违反了缩进规则的程序不能通过编译，以此来强制程序员养成良好的编程习惯；

4、Python语言利用缩进表示语句块的开始和退出（Off-side规则），而非使用花括号或者某种关键字；

5、增加缩进表示语句块的开始，而减少缩进则表示语句块的退出。

6、缩进是Python语法的一部分。

下面的伪代码（并非真正的Python代码）展示了缩进的工作方式：this is a line

this is a line

this is another block

continuing the same block

the last line of this block

phew,there we escaped the inner block

7、很多语言使用特殊单词或者字符（比如begin或{ ）来表示一个语句块的开始，用另外的单词或者字符（比如end或 }）表示语句块的结束。

8、但是在Python中，冒号（：）用来标识语句块的开始，块中的每一个语句都是缩进的（缩进量相同）。

9、当回退到和已经闭合的块一样的缩进量时，就表示当前块已经结束了。

说明：

Python的语句不同于C++等编程语言。Python的语句末尾不需要加分号表示语句结束，直接换行即可。另外很重要的一点，就是使用缩进表示语句块之间的逻辑关系，而不用大括号。这两个特点既保持代码可读性，又减少符号输入提高效率，懒人最爱

缩进的空格数目可变，但统一代码块内相应语句要保持一致，否则报错。下面这个实例代码，由于缩进不一致会出现报错。if True: print ("True")else: print ("else") print ("have a try")

以上就是python通过什么来区分不同的语句块？的详细内容，更多请关注php中文网其它相关文章！

本文原创发布php中文网，转载请注明出处，感谢您的尊重！

1、代码块的基本介绍

代码块又叫初始化块，属于类中的成员，即使类的一部分 类似于方法，将逻辑语句封装在方法提中，通过{ }包围起来。但和方法不同，没有方法名，没有返回值，没有参数，只有方法体，而且不用通过对象或类显示调用，而是在加载类的时候或者创建对象的时候隐式调用。

基本语法
[修饰符]{
代码
};

注意：
1、修饰符可以选，要写的话也只能写 static
2、代码块分为两类，使用static的叫静态代码块，没有static的叫做普通代码块
3、代码中可以为任意逻辑语句例如：输入，输出，方法调用，循环，判断
4、 ; 号可以写上也可以省略

2、代码块的好处

1、对构造器功能的一种补充
2、如果多个构造器中都有重复的语句，可以放到代码块中，提高代码的复用性

三个构造器都有重复的语句，看起来特别的多余

public class codeblock01 {

    public static void main(String[] args) {
    book book = new book("数据结构与算法");
	System.out.println("========================");
    book book1 = new book("kali从入门到入狱", 100, "呀吖呀");
    }

}

class book{
    private String name;
    private double price;
    private String author;
    //3个构造器，构成了重载

    public book(String name) {
        System.out.println("书被打开了");
        System.out.println("书被合上了");
        System.out.println("构造器public book(String name)被调用");
        this.name = name;
    }

    public book(String name, double price) {
        System.out.println("书被打开了");
        System.out.println("书被合上了");
        this.name = name;
        this.price = price;
    }

    public book(String name, double price, String author) {
        System.out.println("书被打开了");
        System.out.println("书被合上了");
        System.out.println("构造器public book(String name, double price, String author)被调用");
        this.name = name;
        this.price = price;
        this.author = author;
    }
}

可以把一样的语句放到一个代码块中即可当我们不管调用哪个构造器，创建对象，都会调用代码块中的代码

3、普通代码块

public class codeblock01 {
    public static void main(String[] args) {
    book book = new book("数据结构与算法");
	System.out.println("========================");
    book book1 = new book("kali从入门到入狱", 100, "呀吖呀");
    }

}

class book{
    private String name;
    private double price;
    private String author;
    //3个构造器，构成了重载
    //三个构造器都有重复的语句，看起来特别的多余
    //可以把一样的语句放到一个代码块中即可
    {
        System.out.println("书被打开了");
        System.out.println("书被合上了");
    }
    public book(String name) {
        //System.out.println("书被打开了");
        //System.out.println("书被合上了");
        System.out.println("构造器public book(String name)被调用");
        this.name = name;
    }

    public book(String name, double price) {
        //System.out.println("书被打开了");
        //ystem.out.println("书被合上了");
        this.name = name;
        this.price = price;
    }

    public book(String name, double price, String author) {
        //System.out.println("书被打开了");
        //System.out.println("书被合上了");
        System.out.println("构造器public book(String name, double price, String author)被调用");
        this.name = name;
        this.price = price;
        this.author = author;
    }
}

这个代码的运行结果都是：

说明：代码块的调用是优先于构造器的！

4、静态代码块

static代码块叫静态代码块，作用是对类进行初始化它随着类的加载进行初始化，而且随着类的加载而被执行并且只会执行一次，如果是普通代码块，每次创建一个对象就执行一次。

先看一段代码

public class codeblock02 {
    public static void main(String[] args) {
        A a = new A();
        
    }
}
class A{

    //静态代码块
    static {
        System.out.println("A的静态代码块正在被执行");
    }
}

执行结果为

得到结论
创建对象实例的时候也就是new的时候。

我们在让A类去继承B类

public class codeblock02 {
    public static void main(String[] args) {
        A a = new A();

    }
}
class A extends B{

    //静态代码块
    static {
        System.out.println("A的静态代码块正在被执行");
    }
}
class B {
    static {
        System.out.println("B的静态代码块正在被执行");
    }
}

得到结论
创建子类对象实例，父类也会被加载，父类先被加载，子类后被加载。

看这段代码

public class codeblock02 {
    public static void main(String[] args) {
        System.out.println(C.n1);

    }
}
class C{
    public static int n1 = 10000;
    static {
        System.out.println("C的静态代码块正在被执行");
    }
}

执行结果为

得到结论
使用类的静态成员时，例如：静态成员，静态方法。

看这段代码

public class codeblock02 {
    public static void main(String[] args) {
        D d = new D();
        D d1 = new D();

    }
}

class D{
    static {
        System.out.println("D的静态代码块被调用");
    }
    {
        System.out.println("D的普通代码块被调用");
    }
}

输出的结果

说明
静态代码块作用是对类进行初始化它随着类的加载进行初始化，而且随着累的加载而被执行并且只会执行一次，
如果是普通代码块，每次创建一个对象就执行一次。

public class codeblock02 {
    public static void main(String[] args) {
        System.out.println(D.n1);
    }
}

class D{
    public static int n1 = 10000;
    static {
        System.out.println("D的静态代码块被调用");
    }
    {
        System.out.println("D的普通代码块被调用");
    }
}

输出结果为

说明
普通代码块需要在new对象的时候才会被调用,而且是每次创建新对象就会被调用。
而静态代码块，只要类加载了就会被调用。

5、类什么时候被加载！！

• 1、创建对象实例的时候也就是new的时候
• 2、创建子类对象实例，父类也会被加载，父类先被加载，子类后被加载
• 3、使用类的静态成员时，例如：静态成员，静态方法

6、创建一个对象时，在一个类中，调用顺序是怎么样的

1. 先调用静态代码块和静态属性初始化。静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码和多个静态变量初始化，就按照定义的顺序执行
2. 调用普通代码块和普通属性的初始化。普通代码块和普通属性的优先级一样，这个和上面的一样
3. 最后在调用构造方法

看代码

public class codeblock03 {
    public static void main(String[] args) {
        AS as = new AS();
    }

}
class AS{


    static {
        System.out.println("AS的静态代码块被调用");
    }
    private static int n1 = getN1();

    public static int getN1(){
        System.out.println("getN1方法被调用");
        return 10000;
    }
    private int n2 = getN2();

    public int getN2(){
        System.out.println("getN2方法被调用");
        return 90000;
    }

    {
        System.out.println("AS的普通代码块被调用");
    }


    public AS(){
        System.out.println("无参构造器被调用");
    }
}

运行结果为

7、存在继承关系时候调用的顺序为

1. 父类的静态代码块和静态属性（优先级一样）
2. 子类的静态代码块和静态属性（优先级一样）
3. 父类的普通代码块和普通属性初始化
4. 父类的构造方法
5. 子类的普通代码块和子类的普通属性初始化
6. 子类的构造方法

注意: 静态代码块只能直接调用静态成员，普通代码块可以调用任意成员

public class codeblock04 {
    public static void main(String[] args) {
        ZL zl = new ZL();
    }
}

class ZL extends FL{
    private static int A = getA();
    private int A1 = getA1();

    public static int  getA(){
        System.out.println("子类的静态方法被调用");
        return 111;
    }

    public int getA1(){
        System.out.println("子类的普通方法被调用");
        return 222;
    }

    static {
        System.out.println("子类的静态代码块被调用");
    }

    {
        System.out.println("子类的普通代码块被调用");
    }

    public ZL(){
        System.out.println("子类的构造器被调用");
    }
}

class FL{
    private static int B = getB();
    private int B1 = getB1();

    public static int getB(){
        System.out.println("FL父类的静态方法被调用");
        return 888;
    }

    public int getB1(){
        System.out.println("FL父类的普通方法被调用");
        return 999;
    }

    static {
        System.out.println("FL父类的静态代码块被调用");
    }

    {
        System.out.println("FL父类的普通代码块被调用");
    }

    public FL() {
        System.out.println("FL父类的构造器被调用");
    }
}

对代码进行分析

运行结果为：

首先看下面的例子，定义一个类，里面包含静态变量、静态方法、静态代码块，如下： 

public class Helper {
    public static String HELP = "help";
    public static void  initHelper(){
        System.out.println("helper init.....");
    }

    static {
        System.out.println("static started.....");
    }
}

1、调用静态变量运行结果如下：也就是说调用静态变量时，静态代码块会执行。

2、调用静态方法运行结果如下：也就是说调用静态方法时，静态代码块会执行，而且多次调用，静态代码块只会执行一次。

3、创建类测试如下：也就是说创建类的时候，静态代码块也会执行。

由上面的例子可以总结出来：

静态代码块在类记载的时候执行，而且只执行一次。一般用来对类初始化数据的定义。

具体如下：

1、调用类静态变量会执行静态代码块

2、调用静态方法时静态代码块会执行

3、创建对象时，静态代码块会执行