Python快速入门，看这一篇就够了

一时失言乱红尘 2024-03-22 10:49 55阅读 0赞

大家好，我是老三，我最近在看一些人工智能相关的东西，大部分相关的框架，都是用Pyhon写的。

老三会用Python，但谈不上多熟练，最近准备拿Python作为自己的第二语言，那么这期我们来一起快速梳理一下Python基础。

## 起步 ##

### Python简介 ###

Python是一门解释性编程语言，既年长又年轻的语言，它诞生于1989年，近些年，人工智能的复兴，给它注入了新的活力。

![Python之父][Python]

“Python”的中文翻译“蟒蛇”，因为Python之父Guido van Rossum，就是这位头发浓密的大叔，喜欢蟒蛇。

Python的主流版本又分为2.X和3.X，2.X已经停止维护，目前Python已经发布到了3.11.2版本。

### 环境准备 ###

我们来看一下在Windows环境下Python的安装。

*  从官网下载Python，版本我们选择3.9.6：https://www.python.org/ftp/python/3.9.6/python-3.9.6-amd64.exe

![Python下载][Python 1]

*  下载完成之后就可以安装了，安装过程选择`Add Pytyon 3.9 to PATH`,这样就可以在任意路径使用Python了，同时也可以自定义一下Python的安装路径，我一般都是安装在D盘。
    
    ![Python安装][Python 2]
 *  `Win+R`打开命令行界面，输入`Python`，会显示Python的版本号，至此Pytyon安装就已经完成，并且打开了Python Shell。

![Python版本][Python 3]

*  我们还默认安装了一个重要的工具——`pip`，它是Python的包管理工具，类似Java的Maven、Node的npm，在命令行界面输入`pip -V`，可以看到pid的版本：
    
    ![pip][]

### 编辑器准备 ###

Python提供了交互式运行工具Python Shell，直接输入一行代码：

print('Hello World.')

万物之始：`Hello World.`

![打印输出][a961f9c92efa44838baf9bc737d0a84f.png]

当然，日常开发肯定不会使用这种交互式的方式，而是使用文件的方式，那么Python文件的编辑器一般使用什么呢？

Python因为是解释性语言，可选的编辑器有很多：Pycharm、Jupyter、Sbulime Text、VSCode……

功能最强大的肯定是Pycharm，但是因为占内存，最重要的是得花钱，所以我一般用VSCode。

*  VSCode的安装就不多说，直接下载安装就可以了
 *  为了更好地利用VSCode开发Python，推荐安装一些插件：
    
    1.  Python：VS Code官方自带插件
        
        ![Python extension for Visual Studio Code][]
    2.  LiveCode for python：可以实时显示每一个变量值
        
        ![LiveCode for python][]
    3.  Sourcery：可以自动审查和改进代码
        
        ![Sourcery][]
    4.  IntelliCode：官方提供的AI辅助开发插件，提供比较充分的代码提示
        
        ![IntelliCode][]
    5.  Python Indent：更好地进行Python代码的缩进
        
        ![Python Indent][]
    6.  Python Test Explorer：可视化代码测试
        
        ![Python Test Explorer][]
    7.  Python Snippets：自动补全代码片段
    
    ![Python Snippets][]

还有其它的一些好用的插件，大家可以自行探索—— 如果有的选，建议Pycharm。

我们来简单体验一下VSCode编写Python代码：

*  创建文件夹`python-demo`

![创建文件夹][b05b96928f8148b882e6681d9490f933.png]

*  使用VSCode打开文件夹，新建文件`hello.py`

![hello.py][]

*  编写代码

print('Hello World.')

*  可以直接在右上角点击运行

![运行][fb5303e390e447de87a2962d67599c92.png]

至此，Python开发环境就已经准备好了，那么我们开始学习Python基础语法。

## 入门 ##

### 基本命令 ###

Python是一门非常简单的语言，我们前面的`print`就是非常简单的打印操作。

Python是一门解释性语言，有点类似`shell`，对缩进要求比较严格，以Tab键或者4个空格进行缩进。

例如，这一段代码就有语法错误：

![语法错误][275902ece2dd449db26c9988f7db9f93.png]

需要改成：

![正确缩进][2ac79d7cf2e749e09547cfdaa40b2c19.png]

Python的注释，使用`#`：

![注释][28c21e9f5ee54229b0d3488f28a5611e.png]

在VSCode里可以使用快捷键`Ctrl+/`快速注释：

![快速注释][1e115e93f1034d3fbe8daf3be66acefa.png]

### 数据类型 ###

Python是一种面向对象的编程语言，所有的数据类型都是类，每个数据值都是类的“实例”，并且不需要显式声明变量的类型。

在Python中有6种主要的内置数据类型：数字（Number）、字符串（string）、列表（list）、元组（tuple）、集合（set）和字典（dict）。

#### 数字（Number） ####

Python中常用的数字类型有两种：`整数(int)`、`浮点(float)`。

我们在Python Shell里进行一些数字的操作：

*  定义和输出

>>> num=1
    >>> print(num)
    1

*  `+`,`-`,`*`,`/`,`%`,`//`,

>>> 2+2
    4
    >>> 60+3*2
    66
    >>> 36/2
    18.0
    >>> 33%10
    3   
    >>> (66-30)*2/4
    18.0
    >>> 19//3
    6

其中`/`会永远返回浮点数float，Python只支持双精度的浮点数float，返回int需要用`//`

*  `int`和`float`转换

>>> int_num=int(8.8)
    >>> print(int_num)
    8

Python 支持其他类型的数字，例如`Decimal` and `Fraction`。 Python 还内置了对`复数（complex）`的支持，当然，用的也不多。

#### 字符串（string） ####

字符串是最常用的数据类型，它可以放在单引号`''`里，也可以放在双引号`“”`里。

>>> 'Good man'
    'Good man'
    >>> "Good man"
    'Good man'

*  字符串连接可以直接使用`+`

>>> "Python is"+"good"
    'Python isgood'

*  如果字符串本身包含单引号`''`或者双引号`“”`，可以使用转义符`\`

>>> "I say:\"Python is good\"."
    'I say:"Python is good".'

*  字符串可以和数字相互转化，字符串转数字可以用`int()`或`float()`，数字转字符串可以用`str()`

>>> int("666")
    666
    >>> float("66.6")
    66.6
    >>> str(888)
    '888'

*  字符串支持下标访问，包括正向索引（正数），和反向索引（负数）

>>> str="The world is so greate."
    >>> str[5]
    'o'
    >>> str[-2]
    'e'

*  字符串使用`find()`查找，`replace()`替换，`split()`切割

#### 列表（list） ####

线性表这种数据结构我们都比较熟悉，Python中的实现是list，类似于Java中的ArrayList，list中可以放入任意类型的变量：

>>> list1=["Python","Good","Study"]
    >>> list2=[1,2,3,4,5]
    >>> list3=["Python",4,"is",12.3,"Good"]

*  元素可以直接通过下标访问：

>>> list1[2] 
    'Study'

*  通过`append()`方法添加元素

>>> list1.append("World")
    >>> print(list1)
    ['Python', 'Good', 'Study', 'World']

*  通过`insert(i，x)`方法在指定位置 插入元素

>>> list1.insert(1,"Should")
    >>> print(list1)
    ['Python', 'Should', 'Good', 'Study']

*  替换元素，可以直接`list[i]=x`

>>> list=[60,80,30,70] 
    >>> list[2]=90
    >>> print(list)
    [60, 80, 90, 70]

*  删除元素，使用`remove(x)`方法

>>> list.remove(60)
    >>> print(list)
    [80, 90, 70]

#### 元组（tuple） ####

列表（list）是一种可变的序列类型，元组（tuple）是一种不可变的序列类型，由多个用逗号隔开的值组成：

>>> t=1314,"love",3,666
    >>> t[0]
    1314
    >>> t
    (1314, 'love', 3, 666)

#### 集合（set） ####

集合（set）是一种可迭代的、无序的、不能包含重复元素的容器类型的数据，类似于Java中的Set。

>>> set={
        50,50,60,90,70,60}
    >>> print(set)
    {
        50, 60, 90, 70}

*  集合的添加用add()，删除用remove()

>>> set.add(100)
    >>> set.remove(50)
    >>> print(set)
    {
        100, 70, 90, 60}

#### 字典（dict） ####

字典（dict）是一种key，value类型的数据结构，类似于Java中的Map。

>>> tel = {
        'jack': 4098, 'sape': 4139}
    >>> print(tel)
    {
        'jack': 4098, 'sape': 4139}

*  可以直接根据key找到value

>>> tel['jack']
    4098

*  添加和更新元素都可以直接通过key

>>> tel['Tommy']=9876
    >>> tel['sape']=5925 
    >>> print(tel)
    {
        'jack': 4098, 'sape': 5925, 'Tommy': 9876}

*  使用`pop()`删除元素

>>> tel.pop('Tommy')
    9876
    >>> print(tel)
    {
        'jack': 4098, 'sape': 5925}

好了，基本的数据结构我们都盘点完了，还有一些api，这里没有给出，建议大家可以直接查看api doc。

![doc][]

### 流程控制 ###

每个语言里都有条件语句、循环语句等等流程控制语句，我们来看看Python中的条件语句和循环语句。

#### 条件语句 ####

##### if语句 #####

# 从控制台获取输入
    score=int(input("请输入你的分数："))
    
    if score>=90:
        print("优秀")  
    if score>=80 and score<90:
        print("良好") 
    if score>=60 and score<80:
        print("及格")      
    if score<60:
        print("不及格")

运行结果：

![运行结果][ed20a31e793a4dab901bab22c54bf2f9.png]

> 在Python里，有三种逻辑运算符：
> 
>  *  not：逻辑非
>  *  and：逻辑与
>  *  or：逻辑或
> 
> 其中and和or都是短路运算。

##### if-else #####

# 从控制台获取输入
    score=int(input("请输入你的分数："))
    
    if score>=60:
        print('及格')
    else:
        print("不及格")

##### if-elif-else #####

# 从控制台获取输入
    score=int(input("请输入你的分数："))
    
    if score>=90:
        print("优秀")  
    elif score>=80:
        print("良好") 
    elif score>=60:
        print("及格")      
    else:
        print("不及格")

#### 循环语句 ####

Python支持两种循环语句：while和for。

##### while #####

i=0
    sum=0
    
    # 0到100的总和
    while i<100:
      sum+=i
      i+=1
       
    print(sum)

##### for #####

Python中的for比较特殊，只能迭代列表、字符串等任意序列，不能迭代算数递增值，或者定义结束条件。

names=['张三','李四','王五','赵六']
    
    for name in names:
      print(name)

运行结果：

![for][]

如果想对数字序列进行迭代呢？那就得用到`range()`函数：

for i in range(6):
      print(i)

如果想要跳出循环，或者跳过本次循环呢？

##### break/continue #####

*  `break`：break用于跳出 [`for`][for 1] 或 [`while`][while] 循环
    
        for i in range(10):
            if i>3:
                #跳出循环
                break
            print(i)
 *  `continue`：continue用于结束本次循环
    
        for i in range(10):
            if i%2==0:
                #跳出本次循环
                continue
            print(i)

##### 容器类型循环 #####

一些集合类型的循环，比如列表、字典，还是非常常用的。

###### 列表循环 ######

*  for循环列表
    
        nums=[1,3,5,7,9]
        
        for i in nums:
            print(i)
 *  while循环，根据下标循环list，和string遍历基本一样
    
        nums=[1,3,5,7,9]
        
        len=len(nums)
        i=0
        
        while i<len:
            print(nums[i])
            i=i+1;
    
     *  用`enumerate()` 函数可以同时取出位置索引和对应的值：
        
            persons=['张三','李四','王五']
            
            for i,v in enumerate(persons):
                print(i,v)

###### 字典遍历 ######

字典是<key,value>类型的结构，遍历和序列结构有一些不一样

*  items()遍历：可以同时取出键和对应的值
    
        person_dict={
              '张三':26,'李四':22,'王五':33}
        
        # 遍历字典中的元素
        for k,v in person_dict.items():
            print(k,v)
 *  遍历keys：可以用keys()函数，当然不用也可以
    
        person_dict={
              '张三':26,'李四':22,'王五':33}
        
        # 遍历keys
        for k in person_dict.keys():
           print(k,person_dict[k]) 
        
        # 不用keys()也可以   
        for k in person_dict:
           print(k,person_dict[k])
 *  遍历values：用values()函数可以直接遍历values
    
        person_dict={
              '张三':26,'李四':22,'王五':33}
        
        # 遍历values
        for v in person_dict.values():
           print(v)

### 函数 ###

我们在写代码的过程中，有很多重复的逻辑，这时候就应该考虑复用这些逻辑，那么就应该定义一些`函数（Functions）`。

比如下面一段代码，创建一个函数，计算长方形的面积：

# 定义函数，计算长方形面积
    def get_area(height,width):
        area=height*width
        return area
    
    # 调用函数：实参顺序和形参一致
    area=get_area(12,8)
    print(area)
    
    # 调用函数：直接指定形参，顺序无限制
    area=get_area(width=9,height=15)
    print(area)

在这个简单的函数里：

*  `def`: Python中用def关键字定义函数
 *  `get_area`：函数名
 *  `height,width`:函数的形参
 *  `area=height*width`：函数体
 *  `return area`：函数的返回值

在调用的时候，如果不直接指定形参，那么实参的顺序要和形参一致。

### 模块 ###

上面我们学习了Python的函数，通过函数我们可以实现很多代码的复用，但是问题来了，所有的函数我们也不能都写在一个文件里，那到后面这个文件就膨胀地不像话了，必须拆分文件。

那么文件拆分后，里面的函数怎么调用呢？这就得用到Python的模块了。

*  写一个`calculate.py`，很简单，里面定义一个简单的函数`add`，这时候`calculate.py`就可以理解为一个模块
    
        # 加法
        def add(a,b):
            return a+b;
 *  再写一个`main.py`，导入模块，调用函数
    
    ![main.py][]
    
        # 导入模块
        import calculate
        
        # 使用模块名调用函数
        print(calculate.add(5,6))
    
    如果模块名太长了，也可以给模块设置别名：
    
        # 导入模块
        import calculate as cal
        
        # 使用模块名调用函数
        print(cal.add(5,6))
    
    假如模块里定义的函数太多了，而我们只需要用某一个函数，或者某几个函数，怎么办？可以只导入模块中的函数：
    
        # 导入模块中的函数
        from calculate import add
        
        #使用模块名调用函数
        print(add(5,6))

Python中也内置了很多模块，常用的有`math`、`datetime`、`os`等等。

例如，利用`datetime`获取当前年月：

#导入日期模块
    import datetime
    
    # 获取当前年、月
    def get_year_and_month():
        now = datetime.datetime.now()
        year=now.year
        month=now.month
        return year,month
    
    year,month=get_year_and_month();
    print(f'{
          year}:{
          month}')

更多的标准库，可以直接查看官方的api文档。

### 面向对象 ###

Python是一门面向对象的语言，面向对象是为了更好地复用代码，接下里，我们看看面向对象的三大特征：`封装`、`继承`、`多态`在Python里是怎么实现的。

#### 类和对象 ####

所谓类就是某个类型，比如人类，所谓对象，就是类的实例，比如张三。

class Person:
        
    def say_hello(n):
        print('你好')
    
    zhansan=Person()
    zhansan.say_hello()

这段代码里定义了一个类`Person`，类里定义了一个方法`say_hello`，实例化了一个对象`zhangsan`，调用了方法。

类里可以有这些成员：

![类的成员][15df96d53b2549e19da5e710ec63cff7.png]

class Person:
        # 类变量
        planet='地球'
        
        # 构造方法，初始化成员变量
        def __init__(self,name,sex,age):
            # 成员变量：姓名，性别，年龄
            self.name=name
            self.sex=sex
            self.age=age
        
        # 实例方法，使用成员变量     
        def say_hello(self):
           print(f'{
          self.name}:你好')
           
        #类方法
        @classmethod
        def breath(cls):
            print('人需要呼吸')  
    
    # 使用构造方法实例化对象并赋值        
    zhansan=Person(name='张三',sex='男',age=22)
    # 调用实例方法
    zhansan.say_hello()   
    # 调用类方法
    Person.breath()

在类中：

*  成员变量也被称为数据成员，类变量属于类，实例变量属于实例。
 *  构造方法用于初始化类的成员变量。
 *  成员方法是在类中定义的函数，包含类方法和实例方法。

我们接下来，看看面向对象的三大特征在Python里是怎么实现的。

#### 封装/继承/多态 ####

##### 封装 #####

封装就是隐藏对象的内部细节，外部只管调用就行了。

Python中的变量默认是公开的，可以在外部的类中访问它们，如果想让它们变为私有变量，在变量前加上双双下画线（\_\_）就行了，变量的获取和设置可以通过get()、set()方法。

class Programer:
        
        # 构造方法，初始化成员变量
        def __init__(self,name):
            # 创建初始化实例变量：姓名
            self.name=name
            # 创建和初始化私有实例变量：_level
            self._level=''
        
        # 实例方法  
        def write_bug(self):
            print(self._level+self.name+'正在写bug中。。')
            
        # get方法
        def get_level(self):
            return self._level
        
        # get方法
        def set_level(self,level):
            self._level=level
          
    # 实例化
    programer =Programer('张三') 
    # 设置私有变量
    programer.set_level('高级工程师') 
    # 调用成员方法  
    programer.write_bug() 
    # 使用get方法获取私有变量  
    print(programer.get_level())

##### 继承 #####

我们现在让Programer继承Person，继承语法很简单，在类后`()`里指定继承的类就行了，可以一个，也可以多个。

from Person import Person
    
    
    # 继承Person
    class Programer(Person):
        
        # 构造方法，初始化成员变量
        def __init__(self,name):
            # 创建初始化实例变量：姓名
            self.name=name
            # 创建和初始化私有实例变量：_level
            self._level=''
        
        # 实例方法  
        def write_bug(self):
            print(self._level+self.name+'正在写bug中。。')
            
        # get方法
        def get_level(self):
            return self._level
        
        # get方法
        def set_level(self,level):
            self._level=level
          
    # 实例化
    programer =Programer('张三') 
    # 设置私有变量
    programer.set_level('高级工程师') 
    # 调用成员方法  
    programer.write_bug() 
    # 使用get方法获取私有变量  
    print(programer.get_level())    
    
    # 调用父类方法
    programer. say_hello()

##### 多态 #####

Python同样支持多态，对于继承，实现多态的方式，就是重写父类的方法：

from Person import Person
    
    
    # 继承Person
    class Programer(Person):
        
        # 构造方法，初始化成员变量
        def __init__(self,name):
            # 创建初始化实例变量：姓名
            self.name=name
            # 创建和初始化私有实例变量：_level
            self._level=''
        
        # 实例方法  
        def write_bug(self):
            print(self._level+self.name+'正在写bug中。。')
            
        # get方法
        def get_level(self):
            return self._level
        
        # get方法
        def set_level(self,level):
            self._level=level
            
        # 重写父类方法
        def say_hello(self):
            print(f"一介开发{
          self.name}向您问好！")   
    
          
    # 实例化
    programer =Programer('张三') 
    # 设置私有变量
    programer.set_level('高级工程师') 
    # 调用成员方法  
    programer.write_bug() 
    # 使用get方法获取私有变量  
    print(programer.get_level())    
    
    # 调用重写了的父类方法
    programer. say_hello()

### 异常处理 ###

对于开发工程师而言，日常最苦恼的事情大概就是写bug和找bug了。

有些时候，我们不希望因为某些错误，导致整个程序停止，那么我们就可以利用`try/except`语句来捕获异常。

比如下面的代码，用`5/0`：

num=5/0

结果就发生了异常：

ZeroDivisionError: division by zero

我们可以捕获这个异常：

try:
        num=5/0
    except Exception as e:
        print(e)

在这段代码里，我们捕获了异常，并把它打印了出来，我们也可以用`pass`空语句，不对异常做任何处理：

try:
        num=5/0
    except Exception as e:
        pass

我们还可以使用`finally`子句，定义所有情况下都必须执行的操作：

try:
        num=5/0
    except Exception as e:
        print(e)
    finally:
        print('end')

## 小结 ##

这一篇几千字的小文章到此就结束了，在这篇文章里，我们快速过了一遍Python环境的搭建，以及各种基础语法，包括数据类型、流程控制语句、函数、模块、面向对象、异常处理。

大家可以看到，Python是一门相对比较好上手的语言，我有个同事这么说——“Python有什么好学的，看看不就会了”。虽然他有吹的成分，但也可以看到，如果有一些编程语言基础，Python上手还是比较简单的。

我们可以先掌握Python基础，把它用起来，用的过程中，再通过文档、搜索引擎、ChatGPT等等，不断加深对细节的掌握。

--------------------

**参考：**

\[1\]. 《Python网络爬虫从入门到实践》

\[2\].https://docs.python.org/3/

\[3\].https://www.jkxuexi.com/resources/191.html

\[4\].《看漫画学Python》

[Python]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/47be441ce6e04cc4a9dac80c7e504e44.png
[Python 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/9f27b39e5af14349912d198038ea92a6.png
[Python 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/466876f158c144608336c82b1e372f72.png
[Python 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/a8356fecc6e34b9aa555d1a7bf7d814b.png
[pip]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/753341582faf42aa93cb613e0f983d9c.png
[a961f9c92efa44838baf9bc737d0a84f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/3ae60198eb514c4fb6e5a6ee952ad8d0.png
[Python extension for Visual Studio Code]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/c99a63eb0dfc40e3b14cde45ef40b965.png
[LiveCode for python]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/3670b5c1cc1f49b8980f6df96d83a995.png
[Sourcery]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/ea659a62bb7a4913b127b5f5e9e6fd06.png
[IntelliCode]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/cd720d24dc5d424da8c45eeaee442a14.png
[Python Indent]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/2f66c79fd1b545f580847e460aca6458.png
[Python Test Explorer]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/79ccb79a659e4c7c9b223c64f4a24882.png
[Python Snippets]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/87ec6ad9d3a6464fb88ed652da85d8eb.png
[b05b96928f8148b882e6681d9490f933.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/9acdd22812b54ea0bbef3575c356a6b9.png
[hello.py]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/8350bb3e32084a908c55fe10f6ea3c3a.png
[fb5303e390e447de87a2962d67599c92.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/120c301e4b3d4e25a9e8c55102262532.png
[275902ece2dd449db26c9988f7db9f93.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/0d6d4537d5414f99a543b33f3dd282fc.png
[2ac79d7cf2e749e09547cfdaa40b2c19.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/9139843780ca43deb090cd03a4c152c8.png
[28c21e9f5ee54229b0d3488f28a5611e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/1a5b2dcfd2c041f9a3c7065f8b819525.png
[1e115e93f1034d3fbe8daf3be66acefa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/618e5f2fa1fb4832a0582bd70ef72d60.png
[doc]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/ab01a0f4de41438c8a0cc617f3872635.png
[ed20a31e793a4dab901bab22c54bf2f9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/df02d3cc30ec4b7e891ed9342cab816c.png
[for]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/f5fe350697394aa2bec4920a405a8608.png
[for 1]: https://docs.python.org/zh-cn/3.9/reference/compound_stmts.html#for
[while]: https://docs.python.org/zh-cn/3.9/reference/compound_stmts.html#while
[main.py]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/b428849542d649eba7e3c76e56f9cfed.png
[15df96d53b2549e19da5e710ec63cff7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/a4fad7b90827420aa8399245cf8f8080.png