悠闲博客

Python异常处理与程序调试

Wed, 21 May 2025 17:40:12 +0800

前言

异常处理是程序用于处理以外情况的代码段，而在代码编写的过程中，经常要进行代码的调试和测试工作。本章将介绍 Python 语言中的异常处理和程序调试的具体使用方法。

一、异常处理

1.1、异常

补充：Exception 类是 Python 中大多数内置异常类的直接或间接父类。当你捕获 Exception 类型的异常时，实际上可以捕获大部分常见的异常情况，但不会捕获一些特殊的、不继承自 Exception 的异常，比如 SystemExit、GeneratorExit 和 KeyboardInterrupt 等。

在人们的工作生活中，做某一件事情的时候，通常并不能很顺序的完成，在做事情的过程中可能会有一些以外的情况发生。比如在开车上班的途中轮胎被扎漏气，就需要先补好车胎再去上班；再比如在写作业时笔坏了，就需要换一支新笔。所以当有意外情况发生时，就需要有对应的解决方法，以便使事情能够继续做下去。对于程序来说，当要完成某一件功能时，有可能也会产生一些以外的情况，这种意外发生的情况在程序中成为异常。

示例1：存在除数为 0 的程序代码示例如下：

print('开始执行除法运算\n\n')
while True:
    str1 = '输入 1 个整数作为第 1 个操作数\n'
    str2 = '输入 2 个整数作为第 2 个操作数\n'
    print('开始执行除法运算\n')
    op1 = int(input(str1))
    op2 = int(input(str2))
    result = op1 / op2
    print('%d / %d = %d' % (op1, op2, result))

仔细阅读这段代码，并没有发现问题。只是在 while 循环进行除法的计算功能。但是请注意：当除数是 0 时，代码中的除法运算是没有意义的。u所以，在这段代码运行过程中，如果输入的第 2 个参数是0，则会出现异常情况，输出结果如下：

开始执行除法运算

输入 1 个整数作为第 1 个操作数
3
输入 2 个整数作为第 2 个操作数
0
Traceback (most recent call last):
  File "D:\VS\Python\pythonProject\work.py", line 8, in <module>
    result = op1 / op2
             ~~~~^~~~~
ZeroDivisionError: division by zero

从程序输出结果中，可以发现：运行这段程序，键盘输入的第 2 个参数是 0 时，程序会产生一个 ZeroDivisionError 异常。Python 编译器将会输出提示信息“division by zero”，并终止程序的运行。就像汽车的车胎被扎一样，需要停下车先补好车胎才能继续开车。程序运行出现异常时，也需要做适当的处理，再继续完成所要实现的功能。一个健壮的程序，不能因为发生异常就中断结束。
常见的异常现象有但不限于：读写文件时，文件不存在；访问数据库时，数据库管理系统没有启动；网络连接中断；算术运算时，除数为 0；序列越界等。
异常（Exception）通常可看作是程序的错误（Error），是指程序是有缺陷（Bug）的。错误分为语法错误和逻辑错误。
语法错误是值Python解释器无法解释代码，在程序执行前就可以进行纠正。逻辑错误是因为不完整或不合法的输入导致程序得不到预期的结果。程序在运行时，如果 Python 解释器遇到一个错误，会停止程序的执行，并且提示一些错误信息，这就是异常。
程序开发时，很难将所有的特俗情况都处理的面面俱到，通过异常捕获可以针对突发事件做集中的处理，从而保证程序的稳定性和健壮性。
示例2：使用 try-except 语句捕获并处理除数为 0 的异常示例代码如下：

print('开始执行除法运算\n\n')
while True:
    str1 = '输入 1 个整数作为第 1 个操作数\n'
    str2 = '输入 2 个整数作为第 2 个操作数\n'
    try:
        print('开始执行除法运算\n')
        op1 = int(input(str1))
        op2 = int(input(str2))
        result = op1 / op2
        print('%d / %d = %d' % (op1, op2, result))
    except ZeroDivisionError:  # 捕获除数为 0 的异常
        print('捕获除数为 0 的异常')

# 结果
开始执行除法运算

开始执行除法运算

输入 1 个整数作为第 1 个操作数
11
输入 2 个整数作为第 2 个操作数
0
捕获除数为 0 的异常
开始执行除法运算

输入 1 个整数作为第 1 个操作数

在示例 2 中，当输入第 2 个参数为 0 时，程序继续到下一次循环执行，也就是异常情况得到了处理，程序并没有因为异常而终止。

这段代码以异常使用 try-except 的语法结果，对引发的异常进行捕获和处理，保证程序能继续执行并获得正确。由此得知，对异常进行处理要分为 2 个阶段，第一个阶段是捕获可能引发的异常，第二个阶段是要对发生的异常进行及时的处理。当异常发生时，不仅能检测到异常条件，还可以在异常发生时采取更可靠的补救措施，排除异常。

示例 1 和示例 2 中的 ZeroDivisionError 时除数为 0 的异常类，Python中还有很多内置的异常类，他们分别表示程序中可能发生的各种异常

异常处理语句主要有四种

示例库:在输入浮点数或除数为0时会异常

def division():
    '''功能：分苹果'''
    print("\n===================== 分苹果了 =====================\n")
    apple = int(input("请输入苹果的个数："))        # 输入苹果的个数
    children = int(input("请输入来了几个小朋友：")) 
    result = apple//children                        # 计算每人分几个苹果
    remain =apple-result*children                   # 计算余下几个苹果
    if remain>0:
        print(apple,"个苹果，平均分给",children,"个小朋友，每人分",result,
              "个,剩下",remain,"个。")
    else:
        print(apple,"个苹果，平均分给",children,"个小朋友，每人分",result,"个。")
if __name__ == '__main__':
    division()                                      # 调用分苹果的函数

1. try...except :可以捕获异常并给出相应的处理结果

语法：

try:

block1 #放入可能产生异常的代码

except [ExceptionName [as alias]]

#[ExceptionName [as alias]]：指定要处理的异常，如果不指定则会会处理所有异常

#[as alias]：给异常指定别名，它可以在输出异常内容时通过别名表示

block2 #放入处理结果，如果block1出现异常就会执行block2中的代码

示例

def division():
    '''功能：分苹果'''
    print("\n===================== 分苹果了 =====================\n")
    apple = int(input("请输入苹果的个数："))                     # 输入苹果的个数
    children = int(input("请输入来了几个小朋友："))
    if apple < children:
        raise ValueError("苹果太少了，不够分...")
    result = apple // children                                   # 计算每人分几个苹果
    remain = apple - result * children                          # 计算余下几个苹果
    if remain > 0:
        print(apple, "个苹果，平均分给", children, "个小朋友，每人分", result,
              "个,剩下", remain, "个。")
    else:
        print(apple, "个苹果，平均分给", children, "个小朋友，每人分", result, "个。")
if __name__ == '__main__':
    try:                                                           # 捕获异常
        division()                                                 # 调用分苹果的函数
    except ZeroDivisionError:                                      # 处理除数为0的异常
        print("\n出错了 ~_~ ——苹果不能被0个小朋友分！")
    except ValueError as e:                                        # 处理值为浮点数的异常
        print("\n出错了 ~_~ ——",e)
 
#也可以一次指定多个异常
# if __name__ == '__main__':
#     try:                                        # 捕获异常
#         division()                              # 调用分苹果的函数
#     except (ZeroDivisionError,ValueError) as e:                   # 处理异常
#         print(e)

2. try...except ...else：在捕获异常时对没有出现异常的情况进行处理

语法：

try:

block1

except [ExceptionName [as alias]]

block2

else:

block3 #没有抛出异常时才执行

示例

def division():
    '''功能：分苹果'''
    print("\n===================== 分苹果了 =====================\n")
    apple = int(input("请输入苹果的个数："))                     # 输入苹果的个数
    children = int(input("请输入来了几个小朋友："))
    if apple < children:
        raise ValueError("苹果太少了，不够分...")
    result = apple // children                                   # 计算每人分几个苹果
    remain = apple - result * children                          # 计算余下几个苹果
    if remain > 0:
        print(apple, "个苹果，平均分给", children, "个小朋友，每人分", result,
              "个,剩下", remain, "个。")
    else:
        print(apple, "个苹果，平均分给", children, "个小朋友，每人分", result, "个。")
if __name__ == '__main__':
    try:                                        # 捕获异常
        division()                              # 调用分苹果的函数
    except (ZeroDivisionError,ValueError) as e:                   # 处理异常
        print(e)
    else:
        print("分苹果顺利完成..")  #代码执行正常后再执行

3. try...except finally #无论是否出现异常，都要执行一段固定的代码

在实际项目开发中经常用来实现与关闭相关的操作，比如关闭文件

语法：

try:

block1

except [ExceptionName [as alias]]

block2

finally:

block3

示例

def division():
    '''功能：分苹果'''
    print("\n===================== 分苹果了 =====================\n")
    apple = int(input("请输入苹果的个数："))                     # 输入苹果的个数
    children = int(input("请输入来了几个小朋友："))
    if apple < children:
        raise ValueError("苹果太少了，不够分...")
    result = apple // children                                   # 计算每人分几个苹果
    remain = apple - result * children                          # 计算余下几个苹果
    if remain > 0:
        print(apple, "个苹果，平均分给", children, "个小朋友，每人分", result,
              "个,剩下", remain, "个。")
    else:
        print(apple, "个苹果，平均分给", children, "个小朋友，每人分", result, "个。")
if __name__ == '__main__':
    try:                                        # 捕获异常
        division()                              # 调用分苹果的函数
    except (ZeroDivisionError,ValueError) as e:                   # 处理异常
        print(e)
    else:
        print("分苹果顺利完成..")
    finally:
        print("进行了一次分苹果操作")

4. 使用raise语句抛出异常

在程序开发时如果某个函数或方法可能会产生异常，但我们不想在当前的函数或方法当中来处理这个异常就可以使用raise语句在这个函数或方法当中来抛出异常，抛出异常后，后面的代码不会再执行

语法：

raise [ExceptionName[(reason)]]

#[ExceptionName[(reason)]]:定义抛出的异常名称，如果省略此参数就会把当前的错误原样抛出

#[(reason)]：异常信息的相关描述，如果省略此参数在抛出异常时就不会附带任何描述信息

示例：模拟幼儿园分苹果（每个人至少分到一个）否则抛出异常

def division():
    '''功能：分苹果'''
    print("\n===================== 分苹果了 =====================\n")
    apple = int(input("请输入苹果的个数："))                  
    children = int(input("请输入来了几个小朋友："))
    if apple < children:
        raise ValueError("苹果太少了，不够分...")
    result = apple // children                                
    remain = apple - result * children                          
    if remain > 0:
        print(apple, "个苹果，平均分给", children, "个小朋友，每人分", result,
              "个,剩下", remain, "个。")
    else:
        print(apple, "个苹果，平均分给", children, "个小朋友，每人分", result, "个。")
if __name__ == '__main__':
    try:                                       
        division()                            
    except (ZeroDivisionError,ValueError) as e:              
        print(e)

程序调试：Python有两种常用调试方法

断点：在进行程序调试运行的时候想让程序在哪里停下来就在哪里设置断点，一个程序中可以设置多个断点

（1）使用python自带的IDLE进行程序调试

打开调试功能：

打开IDLE → Debug → Debugger

debug控制台按钮作用：

Globals：显示全局变量

Go:继续执行

Step：如果在设置的断点处调用了其他的函数，那么单机这个按钮会进入到函数的内部执行

Over：单步执行

Out：跳出函数与Step对应

Quit：结束调试进行修改

设置断点：

光标放在要设置断点的行，鼠标右击选择 SetBreaKpoint

设置好断点后按F5执行代码进行调试

（2）使用assert断言语句调试程序

在 Python 中，assert是一个用于调试和测试的关键字，它主要用于对程序中的条件进行断言，即检查某个条件是否为真。

基本语法

assert语句的基本语法格式为：assert expression[, arguments]。其中，expression是一个表达式，其结果应该为True或False。arguments是可选的，用于在断言失败时提供额外的信息。

工作原理

如果expression的值为True，则assert语句不做任何事情，程序继续正常执行下一条语句。

如果expression的值为False，则assert语句会触发AssertionError异常，表明程序中出现了与预期不符的情况。如果指定了arguments，则会将arguments的值作为异常的参数传递，以便提供更详细的错误信息。

注意：python -O 文件名.py 命令行选项运行程序时，assert语句可能会被忽略，因此不应该使用assert来执行重要的程序逻辑或处理不可恢复的错误。

示例

验证传入的参数是否符合预期；

在编写测试用例时，验证函数或方法的返回值是否符合预期。

def divide(a, b):
    assert b != 0, "除数不能为零"
    return a / b
 
def test_divide():
    assert divide(10, 2) == 5,"1"
    assert divide(5, 1) == 5,"2"
    try:
        assert divide(10, 1) == 0,"3"
    except AssertionError as e:
        print(f"测试失败: {e}")
 
test_divide()

在那些循环或递归等复杂的程序执行过程中，应该始终保持为真的条件

def factorial(n):
    assert n >= 0, "输入必须是非负整数"
    if n == 0 or n == 1:
        return 1
    else:
        result = 1
        for i in range(2, n + 1):
            result *= i
            assert result > 0, "阶乘结果应该始终为正"
        return result

【Python】静态方法 (@staticmethod) 和类方法 (@classmethod)

Wed, 21 May 2025 12:27:15 +0800

Python 提供了两种特殊的方法修饰器（@staticmethod 和 @classmethod），它们分别适用于静态方法和类方法。这两者都可以在不创建类实例的情况下进行调用，但它们的行为和作用是不同的。

1. `@staticmethod` 静态方法

1.1 基本概念

静态方法不与类实例或类绑定，可以直接通过类名调用。
无需访问实例属性或类属性。
类似于类内部的普通函数，与类或实例无关。

1.2 定义静态方法

使用 @staticmethod 装饰器定义静态方法。

class Math:
    @staticmethod
    def add(a, b):
        return a + b

1.3 调用静态方法

# 通过类调用
print(Math.add(5, 10))  # 15

# 通过实例调用
m = Math()
print(m.add(3, 4))  # 7

静态方法可以通过类名或实例调用。
1.4 何时使用静态方法？
当方法不依赖于类或实例属性时，使用 @staticmethod。
适用于工具类、辅助函数、独立于类逻辑的操作。
1.5 示例：实用工具函数

class Utils:
    @staticmethod
    def is_even(num):
        """判断一个数是否是偶数"""
        return num % 2 == 0

print(Utils.is_even(10))  # True
print(Utils.is_even(11))  # False

2. `@classmethod` 类方法

2.1 基本概念

类方法通过 @classmethod 装饰器定义，接受 cls 作为第一个参数。
cls 代表类本身，允许在类方法中访问类属性和修改类状态。
类方法可以通过类名或实例调用。

2.2 定义类方法

class Person:
    count = 0

    @classmethod
    def increment_count(cls):
        cls.count += 1

    @classmethod
    def show_count(cls):
        print(f"当前人数: {cls.count}")

2.3 调用类方法

# 通过类调用
Person.increment_count()
Person.show_count()  # 当前人数: 1

# 通过实例调用
p = Person()
p.increment_count()
p.show_count()  # 当前人数: 2

类方法可以通过类名或实例调用，且会影响类属性。
2.4 何时使用类方法？
当需要访问或修改类级别的属性时，使用 @classmethod。
适用于创建类实例的工厂方法、修改类状态等场景。
2.5 示例：创建实例的工厂方法

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def from_string(cls, data_str):
        """通过字符串创建实例"""
        name, age = data_str.split(",")
        return cls(name, int(age))

# 使用工厂方法创建实例
p1 = Person.from_string("Alice,25")
print(p1.name, p1.age)  # 输出: Alice 25

3. @staticmethod vs @classmethod 区别

特性静态方法 (@staticmethod) 类方法 (@classmethod)

绑定与类或实例无关绑定到类

第一个参数无需 self 或 cls 接受 cls 作为第一个参数

访问权限无法访问类属性可以访问和修改类属性

适用场景与类逻辑无关的独立功能需要操作类级别数据时

调用方式 ClassName.method() 或 instance.method() ClassName.method() 或 instance.method()

4. 使用场景对比

- 静态方法（@staticmethod）使用场景

与类逻辑无关的工具函数

class MathUtils:
    @staticmethod
    def multiply(a, b):
        return a * b

print(MathUtils.multiply(5, 10))  # 50

- 类方法（`@classmethod`）使用场景

需要访问类属性或修改类状态
工厂方法、动态调整类配置

class Counter:
    count = 0

    @classmethod
    def increment(cls):
        cls.count += 1

    @classmethod
    def get_count(cls):
        return cls.count

# 修改类属性
Counter.increment()
Counter.increment()
print(Counter.get_count())  # 2

5. 结合实例方法、静态方法和类方法

class MyClass:
    class_var = "I am a class variable"

    def __init__(self, value):
        self.value = value

    # 实例方法：访问实例和类属性
    def instance_method(self):
        print(f"实例方法: value = {self.value}, class_var = {self.class_var}")

    # 静态方法：不访问实例或类属性
    @staticmethod
    def static_method():
        print("静态方法：不需要访问实例或类")

    # 类方法：访问类属性
    @classmethod
    def class_method(cls):
        print(f"类方法: class_var = {cls.class_var}")

使用示例

# 创建实例
obj = MyClass(10)

# 调用实例方法
obj.instance_method()  # value = 10, class_var = I am a class variable

# 调用静态方法
MyClass.static_method()  # 静态方法：不需要访问实例或类

# 调用类方法
MyClass.class_method()  # 类方法: class_var = I am a class variable

6. 总结

- 静态方法 (@staticmethod)

不与类或实例关联。

不需要 self 或 cls 参数。

适用于工具函数或与类逻辑无关的操作。

- 类方法 (@classmethod)

与类绑定，接受 cls 作为第一个参数。

可以访问和修改类属性。

适用于修改类级别的属性或创建实例的工厂方法。

掌握 @staticmethod 和 @classmethod 将大大提升面向对象编程技能，让 Python 代码更具灵活性和可维护性。

————————————————

原文链接：https://blog.csdn.net/u013172930/article/details/146592461

Windows系统下Mysql压缩包安装详细教程

Sat, 10 May 2025 10:05:16 +0800

1. 下载MySQL压缩包

访问MySQL官方网站：MySQL Downloads

在“MySQL Community Server”部分，选择适合你系统的版本（通常是Windows (x86, 64-bit), ZIP Archive）。

点击“Download”按钮，下载压缩包。

2. 解压MySQL压缩包

将下载的压缩包解压到你想要安装MySQL的目录，例如D:\mysql。

3. 配置环境变量

右键点击“此电脑”或“我的电脑”，选择“属性”。

点击“高级系统设置”，然后点击“环境变量”。

配置两个环境变量

新建系统变量：变量名MYSQL_HOME

变量值MySQL的解压路径

将MySQL_HOME添加到PATH环境变量

%MYSQL_HOME%\bin

最后点击“确定”保存更改。

4. 创建MySQL配置文件

第一步：环境配置完成后，打开mysql文件夹，创建一个新的文件后缀名为 .ini 的 my.ini空白文件。

第二步：编辑创建好的my.ini文件，用于初始化mysql数据库，tips：路径必须为“’\”的形式

[mysql]

# 设置mysql客户端默认字符集

default-character-set=utf8

[mysqld]

# 设置3306端口

port = 3306

# 设置mysql的安装目录

basedir = D:\\mysql\\mysql-8.0.17-winx64

# 设置mysql数据库的数据的存放目录

datadir = D:\\mysql\\mysql-8.0.17-winx64\\data

# 允许最大连接数

max_connections=20

# 服务端使用的字符集默认为8比特编码的latin1字符集

character-set-server=utf8

# 创建新表时将使用的默认存储引擎

default-storage-engine=INNODB

# 创建模式

sql_mode = NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES

你可以根据需要修改 basedir 和 datadir 的路径。

5. 初始化MySQL

打开命令提示符（以管理员身份运行）。

快捷键Windows + R 输入cmd，进入本地Windows 命令行窗口

然后通过命令行进入mysql下的bin文件夹，输入以下命令来初始化MySQL：

mysqld --initialize --console

输入上述命令，按回车，会发现文件夹下会多出一个新的文件夹data。初始化完成后，命令行会显示一个临时密码，请记下这个密码，稍后登录MySQL时会用到

版本不同可能有所偏差

如果命令行没有显示临时密码，那么等待初始化完成后当前目录会生成一个后缀名为.err的文件，里面存放的是初始化登录mysql的密码。

6. 安装MySQL服务

在命令提示符中输入以下命令来安装MySQL服务：

mysqld --install

如果安装成功，你会看到“Service successfully installed”的提示。

如果先前在电脑中装过mysql，请在cmd命令窗口输入sc delete mysql 删除之前的mysql服务。

sc delete mysql

如果出现 Install/Remove of the Service Denied!，则请以管理员身份运行命令行

7. 启动MySQL服务

在命令提示符中输入以下命令来启动MySQL服务：

net start mysql

8. 登录MySQL并修改密码

在命令提示符中输入以下命令来登录MySQL：

mysql -u root -p

输入之前记下的临时密码。

登录成功后，输入以下命令来修改密码：

ALTER USER 'root'@'localhost' IDENTIFIED BY '新密码';

将新密码替换为你想要设置的密码。

9. 验证安装

在命令提示符中输入以下命令来验证MySQL是否安装成功：

mysql -u root -p

输入你设置的密码，如果成功登录，说明MySQL安装成功。

10. 停止和卸载MySQL服务（可选）

如果需要停止MySQL服务，可以使用以下命令：

net stop mysql

如果需要卸载MySQL服务，可以使用以下命令：

mysqld --remove

或者

sc delete mysql

注意事项

确保你以管理员身份运行命令提示符。

如果在安装过程中遇到问题，可以查看MySQL的错误日志文件（通常位于 D:\mysql\data\ 目录下）以获取更多信息。

————————————————

原文链接：https://blog.csdn.net/m0_57376564/article/details/147491162

Windows安装Apache服务

Sat, 10 May 2025 09:10:45 +0800

一、下载Apache

1. Apache官方下载地址

2. 选择需要安装的版本

二、安装Apache

1. 解压安装包

三、配置Apache服务

1. 配置安装路径

四、开启Apache服务

1.进入“bin”目录

2. 检验配置文件是否合法

3. 安装 Apache 主服务

4. 启动 Apache 服务

五、页面访问

一、下载Apache

1. Apache官方下载地址

Welcome! - The Apache HTTP Server Project

https://httpd.apache.org/

点击Download

2. 选择需要安装的版本

可以根据自己的需求安装需要的版本：点击Files for Microsoft Windows

点击Apache Lounge

选择64位或者32位

二、安装Apache

1. 解压安装包

下载完成后，放在自己需要的位置，解压压缩包

三、配置Apache服务

1. 配置安装路径

点击Apache24\conf

右键点击httpd.conf在打开方式中用记事本打开

“Ctrl+H”查找到以 Define SRVROOT

配置Apache安装路径

修改Apache实际绝对安装目录，注意这里用"/"而不是“\”，${SRVROOT}指定义的SRVROOT路径变量

修改以后按“Ctrl+S”保存即可

四、开启Apache服务

1.进入“bin”目录

以管理员身份运行“命令提示符”

用“cd”进入bin目录

cd C:\Users\luoxiang\AppData\Local\Programs\Apache\Apache24\bin

或者直接在“bin”目录进入“命令提示符”

2. 检验配置文件是否合法

进入到bin目录下，使用httpd -t ，检查配置文件是否合法；

显示“Syntax OK”表示没有问题

但是出现了一个错误

httpd: Could not reliably determine the server's fully qualified domain name, using fe80::2748:d433:8602:9657. Set the 'ServerName' directive globally to suppress this message

该错误信息表示Apache无法彻底确定服务器的完全限定域名，只好使用IP地址192.168.1.100来作为主机名称。

简而言之，如果你的服务器IP地址是192.168.1.100，而你也没有在配置文件httpd.conf中设置Apache服务器的主机名称(ServerName)，Apache就无法知道该该服务器的主机名称，只好以192.168.1.100这个IP地址来替代。

要解决这个问题，非常简单。我们只需要在Apache安装目录/conf/httpd.conf文件中启用ServerName配置指令即可。例如：

检查完毕

3. 安装 Apache 主服务

httpd -k install -n apache

该命令的意思是，安装Windows可托管的Apache服务，其中 “-n” 后面参数是自定义Windows服务名称，之后可使用Windows管理服务的命令来管理apache服务，如 “net start/stop apache”（启动 / 停止服务）。

服务安装完毕后，会自动测试，若有问题，窗口会提示错误，此时请根据错误自行排查。

正常安装完毕如下图所示：

安装成功

4. 启动 Apache 服务

启动服务

net start apache

# 或者使用

httpd -k start -n apache

停止服务

net stop apache

# 或者使用

httpd -k stop -n apache

重启服务

# 重启服务

httpd -k restart -n apache

卸载服务

# 卸载服务

## 卸载服务时先停止

httpd -k stop -n apache

## 再卸载服务

httpd -k uninstall -n apache

可视化启动

打开安装apache的 bin 目录，下面有一个 ApacheMonitor.exe 文件，运行即可

双击如果没反应可以看一下小窗口，就是qq、微信、那些最小化存放的地址，有一个这个标志

在这里面可以直接启动、停止、重启操作

五、页面访问

默认端口为80，如需要其他端口可到httpd.conf 配置中自行修改

http://localhost:80/

看到如下页面，则代表安装成功。

————————————————

原文链接：https://blog.csdn.net/qq_61567609/article/details/138942274

如何配置多个 virtualhost使用相同的SSL证书 - Apache

Fri, 02 May 2025 15:16:35 +0800

语境：

我有一个域名： example.com，但我想创建一个像这样的域 api.example.com 使用它像网络服务一样。

昨晚，我有一个免费的SSL证书使用 让我们加密.

我的域名 example.com 应该打开内容 /var/www/website/.

我的域名 api.example.com 应该打开内容 /var/www/api/.

我正在寻找互联网上的一些信息，我创建了这些文件 /etc/apache2/sites-available/

/etc/apache2/sites-available/example.com.

<VirtualHost *:80>
ServerName  example.com
DocumentRoot    /var/www/website/
LogLevel debug
ErrorLog ${APACHE_LOG_DIR}/example.com/error.log
<Directory "/var/www/website/">
Options FollowSymLinks
AllowOverride None
</Directory>
</VirtualHost>
<VirtualHost *:443>
ServerName  example.com
DocumentRoot    /var/www/website/
LogLevel debug
ErrorLog ${APACHE_LOG_DIR}/example.com/error_ssl.log
SSLEngine on
SSLCertificateKeyFile   /etc/apache2/ssl/example.com/privkey.pem
SSLCertificateFile      /etc/apache2/ssl/example.com/cert.pem
SSLCertificateChainFile /etc/apache2/ssl/example.com/chain.pem
<Directory "/var/www/website/">
Options FollowSymLinks
AllowOverride None
</Directory>
</VirtualHost>

/etc/apache2/sites-available/api.example.com.

<VirtualHost *:80>
ServerName  api.example.com
DocumentRoot    /var/www/api/
#RewriteEngine On
#RewriteRule ^(.*)$ https://%{HTTP_HOST}$1 [R=301,L]
<Directory "/var/www/api/">
Options FollowSymLinks
AllowOverride None
</Directory>
</VirtualHost>
<VirtualHost *:443>
ServerName  api.example.com
DocumentRoot    /var/www/api/
LogLevel warn
ErrorLog ${APACHE_LOG_DIR}/error.log
SSLEngine on
SSLCertificateKeyFile   /etc/apache2/ssl/example.com/privkey.pem
SSLCertificateFile      /etc/apache2/ssl/example.com/cert.pem
SSLCertificateChainFile /etc/apache2/ssl/example.com/chain.pem
<Directory "/var/www/api/">
Options FollowSymLinks
AllowOverride None
</Directory>
</VirtualHost>

我创建了两个文件，因为我虽然我们需要分隔域，但是当我尝试输入时 example.com 我有内容 api.example.com.

和 让我们加密，我已经为两个域创建了相同的SSL证书，并且文件所在 /etc/apache2/ssl/example.com/.

看答案

我找到了解决方案！

我已经编辑过了 httpd.conf 和 ports.conf.

/etc/apache2/ports.conf.

# If you just change the port or add more ports here, you will likely also
# have to change the VirtualHost statement in
# /etc/apache2/sites-enabled/000-default
# This is also true if you have upgraded from before 2.2.9-3 (i.e. from
# Debian etch). See /usr/share/doc/apache2.2-common/NEWS.Debian.gz and
# README.Debian.gz
NameVirtualHost *:80
Listen 80
NameVirtualHost *:443
<IfModule mod_ssl.c>
# If you add NameVirtualHost *:443 here, you will also have to change
# the VirtualHost statement in /etc/apache2/sites-available/default-ssl
# to <VirtualHost *:443>
# Server Name Indication for SSL named virtual hosts is currently not
# supported by MSIE on Windows XP.
Listen 443
</IfModule>
<IfModule mod_gnutls.c>
Listen 443
</IfModule>

/etc/apache2/httpd.conf.

SSLStrictSNIVHostCheck on

现在我可以使用该域来网站和WebService

windows10下apache配置多个SSL站点

Fri, 02 May 2025 13:51:08 +0800

Windows 10上配置Apache以运行多个SSL站点，你需要遵循以下步骤。这里假设你已经安装了Apache HTTP服务器，并且已经有SSL证书。

配置Apache

打开Apache配置文件：找到Apache的配置文件httpd.conf或httpd-vhosts.conf（通常位于conf或conf/extra目录下）。
配置虚拟主机：在配置文件中，为每个SSL站点添加一个虚拟主机配置。例如，为domain1.com和domain2.com添加配置：
<VirtualHost *:443>

ServerName domain1.com

DocumentRoot "C:/path/to/domain1"

SSLEngine on

SSLCertificateFile "conf/domain1.crt"

SSLCertificateKeyFile "conf/domain1.key"

</VirtualHost>

<VirtualHost *:443>

ServerName domain2.com

DocumentRoot "C:/path/to/domain2"

SSLEngine on

SSLCertificateFile "conf/domain2.crt"

SSLCertificateKeyFile "conf/domain2.key"

</VirtualHost>

启用模块：确保Apache已经启用了ssl_module。你可以通过运行以下命令来检查和启用它：

```
httpd -M | findstr ssl_module
```

# 检查是否已启用httpd -k install -f "path_to_httpd.conf"

 # 如果未启用，使用此命令重新安装Apache并启用ssl_module（需要重启）

配置端口监听：确保Apache配置文件中监听了443端口。通常这已经在默认配置中设置好了。如果没有，你可以在Listen指令中添加443：
```
Listen 443
```

步骤 4: 重启Apache服务器

配置完成后，保存所有更改并重启Apache服务器以使更改生效：

httpd -k restart

步骤 5: 测试配置

使用浏览器访问你的SSL站点，查看是否能够正确加载页面，并且浏览器没有安全警告。你也可以使用命令行工具如curl来测试：

curl -v https://domain1.com

确保看到的信息中没有SSL错误。

按照以上步骤，你应该能够在Windows 10上成功配置多个SSL站点。如果在实际部署中使用自签名证书，请确保在生产环境中使用由受信任的证书颁发机构（CA）签发的证书。

怎么查看电脑端口是否打开

Tue, 29 Apr 2025 10:44:35 +0800

查看端口是否打开的方法取决于您使用的操作系统。以下是针对Windows和Linux系统的详细步骤：

Windows系统

‌使用命令提示符（CMD）‌

按Win + R打开运行对话框，输入cmd，然后按回车。

使用netstat命令查看所有活动的网络连接及其对应的端口。输入以下命令：

netstat -an

在输出结果中查找您感兴趣的端口号。您可以使用findstr命令来过滤结果，例如查找端口80是否开放：

netstat -an | findstr 80

‌使用PowerShell‌

按Win + X，然后选择“Windows PowerShell”或“Windows PowerShell (管理员)”。

使用Test-NetConnection命令检查某个端口是否开放。例如，检查本地主机上的端口80：

Test-NetConnection -ComputerName localhost -Port 80

Linux系统

‌使用netstat命令‌

打开终端。

输入以下命令查看所有活动的网络连接及其对应的端口：

netstat -tuln

在输出结果中查找您感兴趣的端口号。您可以使用grep命令来过滤结果，例如查找端口80是否打开：

netstat -tuln | grep 80

‌使用ss命令‌

ss是netstat的现代替代品，执行速度更快，效率更高。

输入以下命令查看所有活动的网络连接及其对应的端口：

ss -tuln

同样，您可以使用grep命令来过滤结果。

‌使用lsof命令‌

lsof可以列出当前系统打开的文件和使用这些文件的进程。

输入以下命令查看特定端口是否被占用：

lsof -i :<端口号>

例如，查看端口80是否被占用：

lsof -i :80

‌使用nmap工具‌

nmap是一个网络扫描工具，可以用来探测主机上的开放端口。

首先，确保nmap已安装。如果未安装，您可以使用包管理器进行安装。

输入以下命令检查某个端口是否开放。例如，检查本地主机上的端口80：

nmap -sS -p 80 localhost

注意事项

某些命令可能需要管理员或root权限才能查看所有端口信息。

如果端口未开放，可能是由于防火墙设置阻止了该端口的访问。您可以检查防火墙规则并进行相应的配置。

通过上述方法，您可以有效地检查和确认计算机上的端口状态。

python集合学习实例

Mon, 28 Apr 2025 08:23:34 +0800

st_set={'张三','李四','王五','王五','张三'}

print(st_set,type(st_set),len(st_set))
in_set=set((20,10,50,40,30))
print(in_set,type(in_set),len(in_set))
b={}
print(type(b))
b=in_set
print(type(b))
in_set.add('线三')
in_set.add(25)
print(in_set)
st_ls=25
st_lss=''
# print(in_set.discard(st_ls))
if st_ls in in_set:
    st_lss=in_set.pop()
else:
    print('没有这个值！')
print(in_set,st_lss)

for item in in_set:
    print(item)

for i,item in enumerate(in_set):
    print('{0}----{1}'.format(i,item))

n_list={x for x in range(100) if x%2==0 if x %5==0}
print(type(n_list),len(n_list),n_list)

input_list=[2,3,2,4,5,6,6,6]
n_list=[x**2 for x in input_list]
print(n_list)
n_ser={x**2 for x in input_list}
print(n_ser)

ping 命令结果中 TTL 值代表什么？

Mon, 28 Apr 2025 07:13:55 +0800

ping 命令结果中的 TTL 值代表 “生存时间（Time To Live）”，它本质上是一个计数器。该计数器的初始值由发送方设定，在数据包传输过程中，每经过一个路由器（网络节点），TTL 值就会减 1 。当 TTL 值减为 0 时，路由器会丢弃该数据包，并向源主机返回一个 ICMP 超时消息。TTL 值主要有两个关键作用：一是限制数据包在网络中的生存周期，避免数据包在网络中无限循环；二是帮助用户大致判断数据包经过的路由器数量，从而了解网络路径的状况。不同操作系统通常有各自默认的 TTL 初始值，例如 Windows 系统默认 TTL 初始值一般为 128 ，Linux 系统默认 TTL 初始值一般为 64 。通过 TTL 值，我们能获取网络状态、排查网络故障以及推断目标主机的操作系统类型等信息。

1、TTL 值的工作原理

-初始设定：当源主机发送 ping 数据包时，会为其设置一个 TTL 初始值。这个值是根据操作系统的默认设置来确定的。如前文所述，Windows 系统一般将 TTL 初始值设为 128，Linux 系统设为 64。以 Windows 系统为例，当我们在命令提示符中输入 “ping 192.168.1.1” 时，系统会构建一个 ping 数据包，并赋予其 TTL 值 128。这个初始值就像是给数据包设定了一个 “生命期限”，确保它不会在网络中无休止地传播。

-逐跳递减：数据包在网络中传输时，每经过一个路由器（也称为跃点），路由器都会将数据包的 TTL 值减 1。这是因为路由器需要消耗一定的资源来处理和转发数据包，所以通过减少 TTL 值来表示数据包在网络中的 “生存消耗”。例如，数据包从源主机出发，经过第一个路由器时，TTL 值从 128 变为 127，经过第二个路由器时，TTL 值变为 126，依此类推。

-TTL 为 0 时的处理：当数据包的 TTL 值减为 0 时，当前所在的路由器会丢弃该数据包，并向源主机发送一个 ICMP（Internet 控制消息协议）超时消息。这个超时消息会告知源主机，数据包在传输过程中已超时，未能到达目标主机。比如，当数据包在经过第 128 个路由器后，TTL 值变为 0，此时该路由器就会丢弃数据包，并向源主机返回 ICMP 超时消息，源主机接收到此消息后，在 ping 命令的结果显示中会看到 “请求超时” 的提示。

2、TTL 值在网络故障排查中的应用

-判断网络环路：如果在 ping 操作时，连续收到多个 ICMP 超时消息，且 TTL 值始终不变，这可能意味着网络中存在环路。正常情况下，数据包每经过一个路由器 TTL 值就会减 1，但在网络环路中，数据包会在几个路由器之间不断循环，导致 TTL 值不会正常递减。例如，在一个复杂的企业网络中，如果出现网络环路，ping 某一主机时，可能会持续收到 TTL 值为 127（假设初始值为 128）的 ICMP 超时消息，这就提示网络管理员需要排查网络拓扑，找出并解决环路问题。

-估算网络路径长度：通过观察最终接收到的 ping 响应数据包中的 TTL 值，我们可以大致估算数据包从源主机到目标主机经过的路由器数量。例如，若源主机为 Windows 系统（TTL 初始值 128），收到的 ping 响应中 TTL 值为 125，那么可以推测数据包大约经过了 3 个路由器（128 - 125 = 3）。虽然这种估算并不精确，因为有些路由器可能不会严格按照每跳减 1 的规则处理 TTL 值，但在一定程度上能帮助我们了解网络路径的大致情况，对于网络规划和故障排查有一定的参考价值。

3、通过 TTL 值推断目标主机操作系统类型

-常见操作系统的 TTL 特征：不同操作系统的 ping 数据包 TTL 初始值存在差异，这使得我们可以根据 ping 命令返回的 TTL 值来大致推断目标主机的操作系统类型。除了前面提到的 Windows 系统默认 TTL 初始值一般为 128，Linux 系统默认 TTL 初始值一般为 64 外，Unix 系统默认 TTL 初始值通常也为 255。当然，这些初始值并非绝对固定，有些操作系统允许用户自定义 TTL 初始值，但在大多数默认配置情况下，这些特征值具有一定的参考性。

-推断方法示例：当我们对一个未知操作系统的目标主机执行 ping 命令后，得到的 TTL 值接近 128，那么该主机很可能运行的是 Windows 操作系统；若 TTL 值接近 64，则可能是 Linux 系统；若 TTL 值接近 255，则可能是 Unix 系统。但需要注意的是，这种推断并非 100% 准确，因为有些网络设备可能会修改 TTL 值，而且用户也可以自行调整操作系统的 TTL 初始值。不过，在缺乏其他信息的情况下，通过 TTL 值推断操作系统类型仍是一种简单有效的初步判断方法。

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

拓展阅读：

-如何修改 Windows 系统的 ping 命令 TTL 初始值？：可以通过修改注册表来实现。打开注册表编辑器，找到 “HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters” 路径，在右侧窗口中新建一个名为 “DefaultTTL” 的 DWORD 值，然后根据需要设置其数值数据（例如，设置为 64），重启电脑后生效。但修改注册表有风险，操作前建议备份注册表。

-TTL 值对网络性能有什么影响？：合理的 TTL 值设置能确保网络正常运行，避免数据包在网络中无限制循环占用资源。如果 TTL 初始值设置过小，可能导致数据包无法到达距离较远的目标主机；若设置过大，在网络出现环路时，数据包可能长时间在网络中循环，加重网络拥塞。

-除了 ping 命令，还有哪些方法可以获取目标主机的操作系统类型？：可以使用端口扫描工具（如 Nmap），它不仅能扫描目标主机开放的端口，还能通过分析端口响应特征来推断操作系统类型。另外，一些网络漏洞扫描工具在扫描过程中也能获取关于目标主机操作系统的信息。

————————————————

原文链接：https://blog.csdn.net/weixin_46338972/article/details/147051424

悠闲博客

Python异常处理与程序调试

异常处理语句主要有四种

【Python】静态方法 (@staticmethod) 和类方法 (@classmethod)

1. @staticmethod 静态方法

1.1 基本概念

1.2 定义静态方法

1.3 调用静态方法

1.4 何时使用静态方法？

1.5 示例：实用工具函数

2. @classmethod 类方法

2.1 基本概念

2.2 定义类方法

2.3 调用类方法

2.4 何时使用类方法？

2.5 示例：创建实例的工厂方法

- 类方法（@classmethod）使用场景

5. 结合实例方法、静态方法和类方法

使用示例

推荐10个内网穿透工具，有免费且开源的，也有国产的，太香了！本站测试部分，搭建可用。

Windows系统下Mysql压缩包安装详细教程

Windows安装Apache服务

如何配置多个 virtualhost使用相同的SSL证书 - Apache

/etc/apache2/sites-available/example.com.

/etc/apache2/sites-available/api.example.com.

看答案

/etc/apache2/ports.conf.

/etc/apache2/httpd.conf.

windows10下apache配置多个SSL站点

配置Apache

步骤 4: 重启Apache服务器

步骤 5: 测试配置

怎么查看电脑端口是否打开

python集合学习实例

ping 命令结果中 TTL 值代表什么？

1. `@staticmethod` 静态方法

2. `@classmethod` 类方法

- 类方法（`@classmethod`）使用场景