Python筑基之旅-语句及注释

目录

一、语句的定义

二、语句类型

1、赋值语句

1-1、语法

1-2、功能

1-3、分类及用法

1-2-1、基本赋值

1-2-2、链式赋值

1-2-3、多重赋值

1-2-4、解包赋值

1-2-5、增量赋值

1-2-6、赋值表达式

2、控制流语句

2-1、语法

2-2、功能

2-2-1、条件语句

2-2-2、循环语句

2-2-2-1、for循环语句

2-2-2-2、while循环语句

2-2-3、异常处理语句

2-3、分类及用法

2-3-1、条件语句(if, elif, else)

2-3-2、循环语句(for, while)

2-3-2-1、for循环语句

2-3-2-2、while循环语句

2-3-3、异常处理语句(try, except, finally, raise)

3、定义语句

3-1、语法

3-2、功能

3-2-1、定义函数

3-2-2、定义类

3-3、分类及用法

3-3-1、定义函数

3-3-2、定义类

4、导入语句

4-1、语法

4-2、功能

4-3、分类及用法

4-3-1、导入整个模块

4-3-2、从模块中导入特定的函数或变量

4-3-3、从模块中导入所有内容(不推荐)

4-3-4、导入模块并为其指定别名

5、全局和局部语句

5-1、语法

5-2、功能

5-2-1、全局语句

5-2-2、局部语句

5-3、分类及用法

5-3-1、全局语句

5-3-2、局部语句

6、断言语句

7、删除语句

7-1、语法

7-2、功能

7-3、分类及用法

7-3-1、删除变量

7-3-2、删除列表中的元素

7-3-3、删除字典中的键值对

7-3-4、删除集合中的元素

7-3-5、删除模块中的对象

8、表达式语句

8-1、语法

8-2、功能

8-3、分类及用法

8-3-1、赋值

8-3-2、计算

8-3-3、函数调用

9、退出语句

9-1、exit()函数

9-2、sys.exit()方法

10、传递语句

10-1、语法

10-2、功能

10-3、分类及用法

10-3-1、在类、函数、循环或条件语句中作为占位符

10-3-2、在需要语句块但不想执行任何操作的场景中

三、注释

1、注释的定义

2、注释的类型及用法

2-1、单行注释

2-2、多行注释

四、推荐阅读

1、Python-VBA函数之旅-input()函数

2、Python-VBA函数之旅-open()函数

3、Python算法之旅

4、Python函数之旅

5、个人主页：https://myelsa1024.blog.csdn.net/

一、语句的定义

        在Python中，语句(Statements)是编程的基本单位，用于执行操作或声明。 

二、语句类型

1、赋值语句

1-1、语法

语法：variable = value
参数：
1、variable(必须):表示你要存储值的变量名
2、value(必须):表示要赋给变量的值或表达式

1-2、功能

        在Python中，赋值语句是最基本的语句之一，用于将值或表达式的结果存储在一个或多个变量中。

1-3、分类及用法

1-2-1、基本赋值

x = 1024  # 将整数1024赋值给变量x
name = "Myelsa"  # 将字符串"Myelsa"赋值给变量name

1-2-2、链式赋值

a = b = c = 1024  # a、b和c都被赋值为1024

1-2-3、多重赋值

x, y, z = 1, 2, 3  # x被赋值为1，y被赋值为2，z被赋值为3

1-2-4、解包赋值

# 列表解包
first, second, third = [1, 2, 3]
# 元组解包
a, b, c = (4, 5, 6)
# 字符串解包(注意字符串也是字符序列)
char1, char2, char3 = "abc"
# 字典解包(需要指定键)
person = {"name": "Myelsa", "age": 18}
name, age = person["name"], person["age"]
# 也可以使用**来解包字典为变量(要求变量名与字典键相同)
person = {"name": "Myelsa", "age": 18}
name, age = vars(**person)  # 注意：vars()通常用于获取对象的__dict__属性，这里仅用于示例

1-2-5、增量赋值

x = 10
x += 5  # 相当于 x = x + 5，x现在为15
x *= 2  # 相当于 x = x * 2，x现在为30

1-2-6、赋值表达式

# 从Python 3.8开始，你可以使用海象运算符(:=)在表达式内部进行赋值，这被称为“赋值表达式”或“海象运算符”
some_list = [3, 5, 6, 8, 10, 11, 24, 8, 10, 11, 24]
if (n := len(some_list)) > 10:
    print(f"List is too long ({n} elements)") # 输出：List is too long (11 elements) (假设列表有11个元素，即>10个)
else:
    print(n)   # 输出：7 (前提是列表元素个数≤10个)
# 在这个例子中，n在if语句的条件表达式中被赋值，并且这个值被用于后续的print函数调用中

2、控制流语句

2-1、语法

# 1、条件语句(if, elif, else)语法：
if condition1:
    # code block 1
elif condition2:
    # code block 2
else:
    # code block 3
# 2、循环语句(for, while)
# 2-1、for循环语法：
for variable in iterable:
    # code block
# 2-2、while循环语法：
while condition:
    # code block
# 3、异常处理语句(try, except, finally, raise)
# 3-1、try-except语法：
try:
    # code block to try
except ExceptionType1:
    # code block to handle ExceptionType1
except ExceptionType2 as e:
    # code block to handle ExceptionType2, with error object e
# ... other except blocks ...
else:
    # code block that is executed if no exception is raised
finally:
    # code block that is always executed, regardless of exceptions

2-2、功能

2-2-1、条件语句

        用于根据条件表达式的值(True 或 False)来决定执行哪个代码块。如果`condition1`为真，则执行`code block 1`；如果`condition1`为假且`condition2`为真，则执行`code block 2`；如果两者都为假，则执行`else`后的`code block 3`(如果存在的话)。

2-2-2、循环语句

2-2-2-1、for循环语句

        for循环用于遍历可迭代对象(如列表、元组、字符串、字典、集合等)中的元素，在每次迭代中，`variable`会被赋值为可迭代对象中的下一个元素，并执行相应的代码块。

2-2-2-2、while循环语句

        while循环会一直执行其代码块，直到条件表达式的结果为假(False)，在每次迭代开始时，都会检查条件表达式的值。

2-2-3、异常处理语句

        'try'块包含可能会引发异常的代码，如果`try`块中的代码引发了异常，并且异常的类型与某个`except`块中指定的类型匹配，那么相应的`except`块将被执行；`else`块是可选的，当`try`块中的代码成功执行且没有引发异常时，`else`块将被执行；`finally`块也是可选的，无论是否发生异常，它都会被执行。

2-3、分类及用法

2-3-1、条件语句(if, elif, else)

# 使用条件语句(if,elif,else)来判断一个数字的大小
# 获取用户输入的数字
num = float(input("请输入一个数字: "))
# 使用if, elif, else来判断数字的大小
if num < 0:
    print("你输入的数字是负数！")
elif num == 0:
    print("你输入的数字是零！")
elif 0 < num < 10:
    print("你输入的数字是一个正数，并且在0到10之间！")
else:
    print("你输入的数字是一个正数，并且大于或等于10！")
# 请输入一个数字: 8
# 你输入的数字是一个正数，并且在0到10之间！

2-3-2、循环语句(for, while)

2-3-2-1、for循环语句

# 示例1：遍历列表
# 创建一个列表
my_list = [1, 2, 3, 4, 5]
# 使用for循环遍历列表
for item in my_list:
    print(item)
# 1
# 2
# 3
# 4
# 5
# 示例2：遍历字符串
# 创建一个字符串
my_string = "myelsa"
# 使用for循环遍历字符串(字符串在Python中也是可迭代的)
for char in my_string:
    print(char)
# m
# y
# e
# l
# s
# a
# 示例3：遍历字典
# # 创建一个字典
my_dict = {'name': 'Myelsa', 'age': 18, 'city': 'Guangzhou'}
# 3-1、使用for循环遍历字典的键(keys)
for key in my_dict.keys():
    print(key)
# name
# age
# city
# 3-2、使用for循环遍历字典的值(values)
for value in my_dict.values():
    print(value)
# Myelsa
# 18
# Guangzhou
# 3-3、使用for循环同时遍历字典的键和值(items)
for key, value in my_dict.items():
    print(f"Key: {key}, Value: {value}")
# Key: name, Value: Myelsa
# Key: age, Value: 18
# Key: city, Value: Guangzhou

2-3-2-2、while循环语句

# 1、While 循环示例
# 示例1：简单的计数循环
# 初始化计数器
counter = 0
# 使用while循环进行计数，直到counter达到5
while counter < 5:
    print(counter)
    counter += 1  # 递增计数器
# 0
# 1
# 2
# 3
# 4
# 示例2：从用户输入读取数据，直到输入'quit'
# 无限循环，直到用户输入'quit'
while True:
    user_input = input("请输入一些文本(输入'quit'退出): ")
    if user_input.lower() == 'quit':
        break  # 如果用户输入'quit'，则退出循环
    print("你输入了:", user_input)
# 请输入一些文本(输入'quit'退出): num
# 你输入了: num
# 请输入一些文本(输入'quit'退出): quit

2-3-3、异常处理语句(try, except, finally, raise)

class CustomError(Exception):
    """自定义的异常类"""
    def __init__(self, message):
        self.message = message
def divide_numbers(a, b):
    if b == 0:
        # 显式地引发一个自定义异常
        raise CustomError("除数不能为零!")
    else:
        return a / b
try:
    # 尝试执行可能会引发异常的函数
    result = divide_numbers(1024, 365)
    print(f"结果是：{result}")  # 输出：结果是：2.8054794520547945
    # 尝试执行会引发自定义异常的函数
    result = divide_numbers(10, 0)
except CustomError as e:
    # 捕获自定义异常，并打印错误消息
    print(f"捕获到自定义异常：{e.message}") # 输出：捕获到自定义异常：除数不能为零!
except Exception as e:
    # 捕获其他类型的异常
    print(f"捕获到其他异常：{e}")
finally:
    # finally块中的代码无论是否发生异常都会执行
    print("这是finally块，无论是否发生异常都会执行!") # 输出：这是finally块，无论是否发生异常都会执行!
    # 注意：由于finally块中的代码总是执行，所以下面的输出仍然会显示

3、定义语句

3-1、语法

# 1. 定义函数
# 1-1、语法：使用def关键字，后面跟着函数名、括号内的参数列表，以及一个冒号(:)来表示函数定义的开始；然后，在下一行开始编写函数的实际代码，
#           这些代码应该缩进(通常使用四个空格或一个制表符)，并在函数结束时使用return语句(可选)来返回值
def function_name(parameters):
    """Function docstring (optional)"""
    # function body
    return value  # Optional return statement
# 2. 定义类
# 2-1、语法：使用class关键字，后面跟着类名和一个冒号(:)来开始类的定义；类的主体(即属性和方法的定义)需要缩进(通常使用四个空格或一个制表符)
class ClassName:
    """Class docstring (optional)"""
    # Class variable(s) (optional)
    def __init__(self, parameters):
        """Initializer method, often used to set instance variables."""
        # Instance variable assignments
    def method_name(self, parameters):
        """Method docstring (optional)"""
        # Method body
    # Other methods...

3-2、功能

3-2-1、定义函数

        在Python中，定义函数(Function)的主要功能是为了将一段代码块组织成一个可重用的单元，这样可以在程序的多个地方调用这个函数，而不需要重复编写相同的代码。以下是定义函数的主要功能：

3-2-1-1、代码重用：通过定义一个函数，可以将一段经常需要重复使用的代码封装起来，这样，在需要执行相同操作时，只需要调用这个函数，而不需要重新编写整段代码。

3-2-1-2、模块化编程：函数有助于将复杂的程序分解为更小、更易于管理的部分(即模块)，每个函数负责执行一个特定的任务，这样可以使程序的结构更清晰，更易于理解和维护。

3-2-1-3、提高可读性：当函数被赋予一个有意义的名称时，可以清晰地表达其功能，这样，其他程序员(或未来的你)在阅读代码时，可以更容易地理解代码的目的和工作方式。

3-2-1-4、增强可维护性：如果程序中的某个功能需要修改，只需要修改相应的函数定义，而不需要在整个程序中搜索和修改相关的代码，这大大减少了出错的可能性，并提高了代码的可维护性。

3-2-1-5、简化调试：由于函数将代码分解为更小的部分，因此当程序出现错误时，可以更容易地定位问题所在，此外，还可以单独测试每个函数，以确保它们按预期工作。

3-2-1-6、支持递归：函数可以调用自身，这称为递归；递归是一种强大的编程技术，可以用于解决许多问题，如排序、搜索和遍历数据结构等。

3-2-1-7、封装复杂性：函数可以隐藏实现细节，只提供必要的接口，这样，其他代码只需要了解如何使用这个函数，而不需要关心其内部实现细节，这有助于简化代码的使用和维护。

        总之，定义函数是Python编程中的一个重要概念，它有助于提高代码的可读性、可维护性和可重用性。

3-2-2、定义类

        在Python中，定义类(Class)的主要功能是为了创建具有相同属性和方法的对象的蓝图或模板。类提供了一种将数据和操作这些数据的函数(在类中称为方法)组合在一起的方式，从而创建出具有特定行为和状态的对象。以下是定义类的主要功能：

3-2-2-1、代码重用和封装：通过定义类，我们可以将相关的属性和方法封装在一起，创建一个可重用的模板，这使得我们可以创建多个具有相同属性和方法的对象，而无需为每个对象重复编写相同的代码。

3-2-2-2、数据抽象：类提供了一种将数据(属性)和操作这些数据的方法(函数)结合在一起的方式，这使得我们可以隐藏数据的实现细节，只提供对数据的必要访问和操作，这种抽象性使得代码更加模块化，易于理解和维护。

3-2-2-3、继承和多态：Python中的类支持继承机制，这意味着一个类(子类)可以继承另一个类(父类)的属性和方法，这使得我们可以创建具有层次结构的类，并共享代码。此外，多态性允许我们在不改变代码结构的情况下，使用不同的对象来执行相同的操作。

3-2-2-4、封装私有属性和方法：在Python中，我们可以使用双下划线前缀(如__private_attribute)来定义私有属性和方法，这些属性和方法只能在类内部访问，从而隐藏了实现细节并保护数据的安全性。

3-2-2-5、提供接口：类可以定义一组公共方法，这些方法构成了类的接口，其他代码可以通过这个接口与类的对象进行交互，而无需关心对象的内部实现，这使得我们可以轻松地替换实现细节，只要新的实现符合接口要求即可。

3-2-2-6、实现设计模式：设计模式是解决常见软件设计问题的最佳实践。通过使用类，我们可以实现各种设计模式，如工厂模式、单例模式、观察者模式等，以提高代码的可维护性和可扩展性。

3-2-2-7、支持面向对象编程(OOP)：Python是一种支持面向对象编程的语言，通过定义类，我们可以利用OOP的特性，如封装、继承、多态和抽象等，来创建出更加模块化、可重用和易于维护的代码。

        总之，定义类在Python编程中起着至关重要的作用，它有助于我们创建具有特定属性和方法的对象，提高代码的可重用性、可维护性和可扩展性。

3-3、分类及用法

3-3-1、定义函数

def add_numbers(a, b):
    """  
    这个函数接受两个参数a和b，并返回它们的和
    """
    sum = a + b
    return sum
if __name__ == '__main__':
    result = add_numbers(3, 5)
    print(result)  # 输出：8

3-3-2、定义类

class Person:
    """
    这个类表示一个人，具有name和age属性，以及一个introduce方法
    """
    def __init__(self, name, age):
        """
        初始化方法，用于设置对象的属性
        :param name: 人的名字
        :param age: 人的年龄
        """
        self.name = name
        self.age = age
    def introduce(self):
        """
        介绍自己
        :return: 返回一个描述自己的字符串
        """
        return f"My name is {self.name} and I'm {self.age} years old."
if __name__ == '__main__':
    # 创建Person类的一个实例
    person = Person("Myelsa", 18)
    # 调用实例的introduce方法并打印结果
    print(person.introduce())  # 输出：My name is Myelsa and I'm 18 years old.

4、导入语句

4-1、语法

# 在Python中，导入语句用于将其他模块或库中的代码引入到当前的命名空间中，以便我们可以使用其中的函数、类、变量等
# 1、语法
# 1-1、导入整个模块：
import module_name
# 使用这种方式后，你可以通过`module_name.function_name`或`module_name.ClassName`等方式访问模块中的函数或类
# 1-2、从模块中导入特定的函数或变量：
from module_name import function_name, variable_name
# 使用这种方式后，你可以直接通过`function_name()`或`variable_name`访问这些函数或变量，而不需要通过模块名作为前缀
# 1-3、从模块中导入所有内容(不推荐)：
from module_name import *
# 使用这种方式后，模块中的所有公共函数、类、变量等都会被导入到当前的命名空间中，但这种方式通常不推荐使用，因为它可能会导致命名冲突，并使代码难以阅读和维护
# 1-4、导入模块并为其指定别名：
import module_name as alias_name
# 使用这种方式后，你可以通过`alias_name.function_name`等方式访问模块中的函数或类

4-2、功能

    导入语句的主要功能是将其他模块或库中的代码引入到当前的命名空间中，以便我们可以使用其中的函数、类、变量等，这使得Python的代码更加模块化，易于管理和复用。

4-3、分类及用法

4-3-1、导入整个模块

# 示例1: 导入math模块
import math
# 使用math模块中的函数
print(math.sqrt(16))  # 输出：4.0 (平方根)
print(math.sin(math.pi / 2))  # 输出：1.0 (sin(π/2))
# 示例2: 导入os模块
import os
# 使用os模块中的函数
print(os.getcwd())  # 输出当前工作目录
print(os.listdir('.'))  # 输出当前目录下的文件和文件夹列表
# 示例3: 导入自定义模块
# 假设你有一个名为my_module.py的自定义模块，它包含一些函数和变量
# my_module.py(在同一目录下)
# my_module.py
def say_hello():
    print("Hello from my_module!")
greeting = "Hello, World!"
# 主程序(与my_module.py在同一目录下)
# main_program.py  
import my_module
# 调用my_module中的函数  
my_module.say_hello()  # 输出：Hello from my_module!  
# 访问my_module中的变量  
print(my_module.greeting)  # 输出：Hello, World!

4-3-2、从模块中导入特定的函数或变量

# 示例1: 从math模块中导入sqrt和sin函数
from math import sqrt, sin
# 使用导入的函数
print(sqrt(16))  # 输出：4.0 (平方根)
print(sin(0))  # 输出：0.0 (sin(0))
# 示例2: 从os模块中导入getcwd和listdir函数
from os import getcwd, listdir
# 使用导入的函数
print(getcwd())  # 输出当前工作目录
print(listdir('.'))  # 输出当前目录下的文件和文件夹列表
# 示例3: 从自定义模块中导入特定的函数和变量
# 假设你有一个名为my_module.py的自定义模块，内容如下：
# my_module.py
def say_hello():
    print("Hello from my_module!")
def greet(name):
    print(f"Hello, {name}!")
greeting = "Hello, World!"
# 你可以在主程序中只导入特定的函数和变量：
# main_program.py
from my_module import say_hello, greet
# 调用导入的函数
say_hello()  # 输出：Hello from my_module!
greet("Myelsa")  # 输出：Hello, Myelsa!
# 注意：如果你没有导入greeting变量，你将不能直接访问它
# print(greeting)  # 这会抛出一个NameError

4-3-3、从模块中导入所有内容(不推荐)

# 假设你有一个名为my_module.py的自定义模块，内容如下：
# my_module.py
def function1():
    print("This is function1 from my_module.")
def function2():
    print("This is function2 from my_module.")
variable1 = "This is variable1 from my_module."
variable2 = "This is variable2 from my_module."
class MyClass:
    def __init__(self):
        print("This is MyClass from my_module.")
# 现在，如果你想在主程序中导入这个模块的所有内容，你可以使用星号(*)作为通配符：
# main_program.py
from my_module import *
# 调用函数
function1()  # 输出：This is function1 from my_module.
function2()  # 输出：This is function2 from my_module.
# 访问变量
print(variable1)  # 输出：This is variable1 from my_module.
print(variable2)  # 输出：This is variable2 from my_module.
# 创建类的实例
obj = MyClass()  # 输出：This is MyClass from my_module.

4-3-4、导入模块并为其指定别名

# 示例1：导入math模块并为其指定别名m
import math as m
# 使用指定的别名调用math模块中的函数
print(m.sqrt(16))  # 输出：4.0 (平方根)
print(m.sin(m.pi / 2))  # 输出：1.0 (sin(π/2))
# 示例2: 导入自定义模块my_long_module_name并为其指定别名short_name
# 首先，假设你有一个名为my_long_module_name.py的自定义模块，内容如下：
# my_long_module_name.py
def say_hello():
    print("Hello from my_long_module_name!")
# 然后，在你的主程序中，你可以这样导入它并为其指定别名：
import my_long_module_name as short_name
# 使用指定的别名调用函数
short_name.say_hello()  # 输出：Hello from my_long_module_name!
# 示例3: 从模块中导入特定的函数并为其指定别名
from math import sqrt as square_root
# 使用指定的别名调用函数
print(square_root(16))  # 输出：4.0 (平方根)

5、全局和局部语句

5-1、语法

        全局变量定义在函数或类之外，可以在程序的任何地方访问；而局部变量定义在函数或类的方法内部，只能在定义它们的函数或方法内部访问。

5-2、功能

5-2-1、全局语句

        global和nonlocal语句用于声明变量是全局的或来自封闭命名空间的非局部变量。

5-2-2、局部语句

        local语句用于声明变量是局部的或定义在函数或类的方法内部的局部变量。

5-3、分类及用法

5-3-1、全局语句

# 这是一个全局变量
global_variable = 1024
def function_example():
    # 这里可以访问全局变量
    print(global_variable)
function_example()  # 输出: 1024

5-3-2、局部语句

# 这是一个全局变量
global_variable = 1024
def function_example():
    # 这是一个局部变量
    local_variable = 2048
    # 这里访问的是局部变量
    print(local_variable) # 输出：2048
    # 如果要访问全局变量，需要使用global关键字
    global global_variable
    print(global_variable) # 输出：1024
function_example()  

6、断言语句

        在Python中，断言(Assertions)是一种用于调试目的的语句，它可以在程序的关键点进行测试。断言使用assert关键字来声明，并附带一个表达式，当表达式的值为False时，会引发一个AssertionError异常。 

# 语句类型：断言(Assertions)语句
# 1、语法：assert expression[, arguments]
# 2、参数：
# 2-1、expression：这是一个布尔表达式，如果其值为False，则会触发断言失败
# 2-2、arguments(可选)：当断言失败时，这些参数会被传递给AssertionError异常，并转换为异常的错误消息；通常，这些参数是一个描述断言失败的字符串
# 3、功能：
# 3-1、调试代码：在开发和测试过程中，使用断言可以快速地检查代码中的关键条件是否满足预期
# 3-2、文档化代码：断言可以作为一种代码注释的形式，说明代码中的某些条件必须为真
# 3-3、运行时检查：断言可以在运行时检查程序的状态，以确保程序按照预期运行
# 4、用法：
# 示例1：检查变量是否为正数
x = -5
assert x > 0, "x必须是正数！"
# AssertionError: x必须是正数！
# 示例2：检查列表是否为空
my_list = []
assert my_list, "列表不能为空！"  # 注意：空列表在布尔上下文中为False
# AssertionError: 列表不能为空！
# 示例3：更复杂的断言条件
y = -3
z = 4
assert y * z == -12, "y和z的乘积应该等于-12"
# 如果断言失败，将会抛出一个AssertionError异常，并显示指定的错误消息
try:
    assert False, "这是一个失败的断言"
except AssertionError as e:
    print(e)  # 输出: 这是一个失败的断言

7、删除语句

        在Python中，删除(Del)语句通常指的是使用del关键字来删除变量、列表中的元素、字典中的键值对或集合中的元素。 

7-1、语法

# 语句类型：删除(Del)语句
# 1、语法：del target
# 2、参数：target，表示要被删除的对象，可以是变量、列表元素、字典键、集合元素等

7-2、功能

        del语句的主要功能是删除指定的目标对象，从而释放其占用的内存空间，它不会触发任何形式的回收机制，只是简单地移除目标对象的引用。

7-3、分类及用法

7-3-1、删除变量

x = 10
del x  # 删除变量x
print(x)  # 将引发NameError，因为x已经被删除了
# NameError: name 'x' is not defined

7-3-2、删除列表中的元素

my_list = [1, 2, 3, 4, 5]
del my_list[2]  # 删除索引为2的元素  
print(my_list)  # 输出: [1, 2, 4, 5]
del my_list[1:3]  # 删除索引为1到2(不包括3)的元素
print(my_list)  # 输出: [1, 5]

7-3-3、删除字典中的键值对

my_dict = {'a': 1, 'b': 2, 'c': 3}
del my_dict['b']  # 删除键为'b'的键值对
print(my_dict)  # 输出: {'a': 1, 'c': 3}

7-3-4、删除集合中的元素

my_set = {1, 2, 3, 4}
# del my_set[2]  # 这是错误的，因为集合不支持通过索引删除元素
# TypeError: 'set' object doesn't support item deletion
# 正确的删除方法是通过元素值
my_set.remove(3)  # 或者使用discard方法(如果元素不存在则不会抛出异常)
print(my_set)  # 输出: {1, 2, 4}
# 如果使用del，则需要先转换成列表或其他可索引的数据结构
temp_list = list(my_set)
del temp_list[temp_list.index(2)]
my_set = set(temp_list)
print(my_set)  # 输出: {1, 4}，但这种方法并不直接，且效率低下

7-3-5、删除模块中的对象

import math  
del math.sqrt  # 删除math模块中的sqrt函数，但不推荐这样做

8、表达式语句

        在Python中，表达式语句(Expression Statement)是由表达式组成的语句，这些表达式通常用于赋值、计算、调用函数等。

8-1、语法

        表达式(Expression)语句的语法非常简单，基本上就是一个或多个表达式，后面跟着一个可选的分号(;)。然而，在Python中，分号通常是不必要的，因为Python使用换行符来分隔语句，但在某些情况下，例如在一行中编写多个语句时，可以使用分号(;)。

# 1、语法：
# 1-1、expression
# 1-2、target = expression
# 2、参数：
# 2-1、target：一个可以赋值的对象，如变量、属性、列表元素、字典条目等
# 2-2、expression 是任何有效的Python表达式

8-2、功能

        表达式(Expression)语句的主要功能是计算和/或执行表达式的值。

8-3、分类及用法

8-3-1、赋值

# 变量赋值  
x = 10
# 属性赋值  
obj.attribute = 20
# 列表元素赋值  
my_list = [1, 2, 3]
my_list[1] = 4  # 将列表中索引为1的元素赋值为4  
# 字典条目赋值  
my_dict = {'a': 1, 'b': 2}
my_dict['c'] = 3  # 添加或更新字典中的'c'键对应的值

8-3-2、计算

# 简单的数学运算
result = 2 + 3 * 4  # 注意Python的运算优先级
# 逻辑运算
is_true = True and False
# 字符串操作
greeting = "Hello, " + "world!"

8-3-3、函数调用

# 定义一个函数
def greet(name):
    return "Hello, " + name + "!"
# 调用函数并将结果赋值给变量  
message = greet("Myelsa")
print(message)  # 输出 "Hello, Myelsa!"

9、退出语句

        在Python中，exit()函数或sys.exit()方法常常被用来退出程序。但是，严格来说，它们并不是Python语言的“语句”(statement)，而是函数或方法调用，不过，它们确实提供了退出程序的功能。

9-1、exit()函数

# 1、语法：exit([status])
# 2、参数：status(可选):表示退出状态码
# 3、功能：退出当前运行的Python程序，并返回指定的状态码(如果有)
# 4、用法：
# 退出程序，返回状态码0  
exit()
# 退出程序，返回状态码1  
exit(1)
# 在条件语句中使用exit  
if some_condition:
    print("An error occurred.")
    exit(1)

9-2、sys.exit()方法

# 1、语法：
      import sys
      sys.exit([status])
# 2、参数：status(可选):表示退出状态码
# 3、功能：与 exit()函数相同，退出当前运行的Python程序，并返回指定的状态码(如果有)
# 4、用法：
import sys
# 退出程序，返回状态码0
sys.exit()
# 退出程序，返回状态码1
sys.exit(1)
# 在条件语句中使用sys.exit
if some_condition:
    print("An error occurred.")
    sys.exit(1)

10、传递语句

        在Python中，传递语句(pass statement)并不是一个用于传递数据或信息的语句，而是一个空操作语句。它不做任何事情，只是简单地作为一个占位符，当语法上需要一个语句但程序逻辑上不需要任何操作时，可以使用pass语句。

10-1、语法

pass

10-2、功能

    pass语句的功能主要是作为占位符，用于保持程序结构的完整性，它允许你编写一个空语句块，这对于满足语法要求但不需要实际执行任何操作的场景非常有用。

10-3、分类及用法

10-3-1、在类、函数、循环或条件语句中作为占位符

class MyClass:
    def my_method(self):
        # 尚未实现具体功能，使用pass作为占位符  
        pass
def my_function():
    # 占位符，后续将添加代码  
    pass
for i in range(10):
    # 尚未确定循环体内容，使用pass  
    pass
if some_condition:
    # 尚未确定条件分支的代码，使用pass  
    pass

10-3-2、在需要语句块但不想执行任何操作的场景中

def optimize_function():  
    # 根据某些条件决定是否进行优化  
    if not should_optimize:  
        # 不进行优化，使用pass作为空操作  
        pass  
    else:  
        # 执行优化代码  
        ...

三、注释

1、注释的定义

        在Python中，注释(Comment)是一种用于解释代码、添加说明或暂时禁用某些代码行的方法。

2、注释的类型及用法

2-1、单行注释

        使用#符号来标记注释的开始，从#开始到该行结束的所有内容都将被视为注释，Python解释器在执行代码时会忽略这部分内容。

# 这是一个单行注释  
print("Hello, World!")  # 这部分也是注释，但位于代码行的末尾

2-2、多行注释

        Python没有专门的多行注释语法，但你可以使用多个单行注释或者使用三引号(''' 或 """)来包围多行文本作为字符串，但如果不将这个字符串赋值给任何变量或作为函数的一部分，那么这个字符串就相当于多行注释(尽管从技术上说它是一个未使用的字符串字面量)。

"""
这是一个多行注释的示例
你可以在这里写很多行来解释你的代码
但请注意，这实际上是一个多行字符串，而不是真正的注释
"""
print("Hello, World!")
''' 
这是一个多行注释的示例  
你可以在这里写很多行来解释你的代码 
但请注意，这实际上是一个多行字符串，而不是真正的注释 
'''
print("Hello, Myelsa!")
# Hello, World!
# Hello, Myelsa!

四、推荐阅读

1、Python-VBA函数之旅-input()函数

2、Python-VBA函数之旅-open()函数

3、Python算法之旅

4、Python函数之旅

5、个人主页：https://myelsa1024.blog.csdn.net/