Tag: Python

  • 超越Python性能极限:创建C++扩展模块

    超越Python性能极限:创建C++扩展模块

    你是否曾想过如何提高Python代码的性能?或者你是否在处理大规模数据时感到Python的速度有些慢?如果是的话,那么你来对地方了!在本篇文章中,我将带你走进C++的魔幻世界,教你如何创建C++扩展模块,以实现超越Python性能的目标。不要担心,即使你不是C++专家,我也将为你详细解释每一步。

    前提条件

    在开始之前,确保你已经安装了Visual Studio 2017或更新版本,同时安装了Python开发工作负载。这个工作负载包括Python本地开发工具,这对于创建本地扩展模块是必要的。如果你已经在使用Python,也确保在高级选项下选择了下载调试符号,以便进行Python代码和本地代码的混合模式调试。

    创建Python应用程序

    首先,我们将创建一个Python应用程序,这将是我们要扩展的Python代码。在Visual Studio中,选择文件 > 新建 > 项目。

    搜索Python,选择Python应用程序模板,输入名称和位置,然后点击确定。

    在项目的.py文件中,粘贴以下代码,这段代码会计算双曲正切,我们将在后面的步骤中加速它。

    from random import random
    from time import perf_counter
    
    COUNT = 500000
    
    DATA = [(random() - 0.5) * 3 for _ in range(COUNT)]
    
    e = 2.7182818284590452353602874713527
    
    def sinh(x):
        return (1 - (e ** (-2 * x))) / (2 * (e ** -x))
    
    def cosh(x):
        return (1 + (e ** (-2 * x))) / (2 * (e ** -x))
    
    def tanh(x):
        tanh_x = sinh(x) / cosh(x)
        return tanh_x
    
    def test(fn, name):
        start = perf_counter()
        result = fn(DATA)
        duration = perf_counter() - start
        print('{} took {:.3f} seconds\n\n'.format(name, duration))
    
    if __name__ == "__main__":
        print('Running benchmarks with COUNT = {}'.format(COUNT))
    
        test(lambda d: [tanh(x) for x in d], '[tanh(x) for x in d] (Python implementation)')

    通过调整COUNT变量,你可以改变基准测试的运行时间。现在,选择调试 > 以不带调试启动,来运行这个程序。

    创建核心C++项目

    接下来,我们将创建两个C++项目,分别是superfastcode和superfastcode2,用于扩展Python。

    1. 在解决方案资源管理器中,右键单击解决方案,然后选择添加 > 新建项目。这样,一个Visual Studio解决方案可以同时包含Python和C++项目。

    2. 搜索C++,选择空项目模板,为第一个项目命名superfastcode,然后点击确定。

    3. 创建一个C++文件,右键点击Source Files节点,选择添加 > 新项。选择C++文件,命名为module.cpp,然后点击确定。

    4. 在主工具栏上,使用下拉菜单选择以下配置之一:

      • 对于64位Python运行时,激活x64配置。
      • 对于32位Python运行时,激活Win32配置。
    5. 在解决方案资源管理器中,右键单击C++项目,选择属性,然后按照以下表格中的设置进行配置:

      选项卡 属性 值
      General 目标名称 指定模块的名称,以便在Python中引用。如果要使用项目名称作为模块名称,请保留默认值$。对于python_d.exe,添加_d以结束名称。
      Advanced > Target File Extension .pyd
      Project Defaults > Configuration Type Dynamic Library (.dll)
      C/C++ > General 附加包含目录 根据你的安装情况添加Python包含目录(例如,c:\Python36\include)。
      C/C++ > Preprocessor 预处理器定义 如果存在,请将_DEBUG值更改为NDEBUG,以匹配CPython的非调试版本。当使用python_d.exe时,保持此值不变。
      C/C++ > Code Generation 运行时库 选择多线程DLL(/MD)以匹配CPython的非调试版本。当使用python_d.exe时,保持此值为多线程调试DLL(/MDd)。
      Basic Runtime Checks 默认
      Linker > General 附加库目录 添加包含.lib文件的Python libs文件夹,根据你的安装情况(例如,c:\Python36\libs)。确保指向包含.lib文件的libs文件夹,而不是包含.py文件的Lib文件夹。
    6. 构建C++项目以确认代码正确。

    7. 如果尚未完成,重复上述步骤创建第二个项目,命名

    为superfastcode2。这个项目将在后面的示例中使用。

    编写Python扩展模块

    我们已经有了一个C++项目,现在让我们开始编写Python扩展模块。

    1. 在superfastcode项目中,打开module.cpp文件,然后将以下代码添加到文件顶部:
    #include <Python.h>

    这会包括Python头文件,以便在C++代码中使用Python API。

    1. 在文件中,添加以下C++函数,这些函数将成为Python模块的接口:
    static PyObject* superfastcode_tanh(PyObject* self, PyObject* args)
    {
        // Parse the input arguments
        PyObject* data;
        if (!PyArg_ParseTuple(args, "O", &data))
        {
            PyErr_SetString(PyExc_TypeError, "Invalid input");
            return NULL;
        }
    
        // Ensure data is a list
        if (!PyList_Check(data))
        {
            PyErr_SetString(PyExc_TypeError, "Input must be a list");
            return NULL;
        }
    
        // Iterate through the list and apply tanh function
        PyObject* result = PyList_New(0); // Create an empty list
        if (result != NULL)
        {
            Py_ssize_t size = PyList_Size(data);
            for (Py_ssize_t i = 0; i < size; ++i)
            {
                PyObject* item = PyList_GetItem(data, i);
                double x = PyFloat_AsDouble(item);
                if (!PyErr_Occurred())
                {
                    double tanh_x = tanh(x);
                    PyObject* tanh_item = PyFloat_FromDouble(tanh_x);
                    if (tanh_item != NULL)
                    {
                        PyList_Append(result, tanh_item);
                        Py_DECREF(tanh_item);
                    }
                    else
                    {
                        PyErr_SetString(PyExc_RuntimeError, "Failed to create float object");
                        Py_DECREF(result);
                        return NULL;
                    }
                }
                else
                {
                    PyErr_SetString(PyExc_TypeError, "Invalid item in the input list");
                    Py_DECREF(result);
                    return NULL;
                }
            }
        }
    
        return result;
    }
    
    static PyMethodDef superfastcode_methods[] =
    {
        {"tanh", superfastcode_tanh, METH_VARARGS, "Calculate the hyperbolic tangent of a list of numbers."},
        {NULL, NULL, 0, NULL}
    };
    
    static struct PyModuleDef superfastcode_module =
    {
        PyModuleDef_HEAD_INIT,
        "superfastcode",
        NULL,
        -1,
        superfastcode_methods
    };
    
    PyMODINIT_FUNC PyInit_superfastcode(void)
    {
        return PyModule_Create(&superfastcode_module);
    }

    这些代码定义了一个名为superfastcode的Python模块,其中包括一个名为tanh的函数。这个函数将接受一个Python列表作为输入,计算列表中每个数字的双曲正切,并返回一个包含结果的新列表。

    1. 构建superfastcode项目以生成扩展模块。

    使用Python中的扩展模块

    现在,我们已经创建了一个C++扩展模块,让我们看看如何在Python中使用它。

    1. 在Python中,创建一个新的.py文件,例如test_superfastcode.py,并添加以下代码:
    import superfastcode
    
    data = [0.5, 0.6, 0.7, 0.8, 0.9]
    result = superfastcode.tanh(data)
    print(result)

    这个Python脚本导入了我们的superfastcode模块,并使用其中的tanh函数来计算输入列表的双曲正切。

    1. 运行test_superfastcode.py文件,你将看到计算结果。

    结论

    通过创建C++扩展模块,我们可以将高性能的C++代码与Python集成在一起,实现更快的计算速度。这对于需要处理大量数据或需要高性能计算的应用程序特别有用。希望本文对你有所帮助,让你更好地理解如何创建和使用Python扩展模块。如果你对此有任何疑问或需要进一步的帮助,请随时提问!

  • 如何使用Django的管理命令在Azure上运行Python Web应用

    如何使用Django的管理命令在Azure上运行Python Web应用

    你是否正在开发一个使用Django框架构建的Python Web应用,并希望将它部署到Azure云上?如果是的话,你来对地方了!在本教程中,我们将向你展示如何在Azure上托管你的Python Web应用,并使用Django的管理命令来执行各种管理任务。无论是创建数据库、应用迁移还是收集静态文件,Django的管理命令可以帮助你高效地管理你的Web应用。

    开篇故事

    假设你是一位年轻的开发者,充满激情地开发着自己的Python Web应用。你的应用具有许多令人兴奋的功能,但现在你面临着一个新的挑战:将它部署到云上,以便可以随时随地访问。你听说Azure是一个强大的云平台,可以帮助你实现这一目标。但是,你可能还不太清楚如何在Azure上托管你的应用,以及如何使用Django的管理命令来管理它。

    在本教程中,我们将向你展示从头开始部署Python Web应用到Azure的过程,以及如何使用Django的管理命令来执行各种任务,从数据库迁移到收集静态文件,一步步带你完成整个过程。无论你是一个新手还是一个有经验的开发者,这个教程都将为你提供宝贵的指导。

    步骤 1:准备工作

    在开始之前,确保你已经完成了以下准备工作:

    • 一个活跃的Azure帐户。如果你没有Azure帐户,可以免费创建一个。
    • 安装了Python,并且版本为3.9或更高版本。
    • 熟悉Django框架,并且已经创建了一个Python Web应用。

    步骤 2:创建Django项目

    首先,让我们确保你的Django项目已经创建并正常运行。如果你已经有一个现成的项目,可以跳过这一步。

    使用以下命令在本地创建一个新的Django项目:

    django-admin startproject myproject

    然后,进入项目目录:

    cd myproject

    运行以下命令以确保你的项目可以正常运行:

    python manage.py runserver

    现在,你的Django项目应该在本地运行并且可以在浏览器中访问。如果一切正常,让我们继续下一步。

    步骤 3:配置Django项目以在Azure上运行

    在Azure上托管Django项目之前,我们需要对项目进行一些配置,以适应云环境。首先,让我们来修改Django项目的settings.py文件。

    打开myproject/settings.py文件,并找到ALLOWED_HOSTS设置。将其修改为:

    ALLOWED_HOSTS = ['*']

    这将允许任何主机访问你的应用程序,但在生产环境中,你应该更改为允许的主机列表。

    接下来,让我们创建一个新的Django设置模块,以便在Azure上使用不同的设置。在项目根目录中,创建一个名为production.py的新文件,并将其配置为以下内容:

    from .settings import *
    
    DEBUG = False
    
    # Update the secret key to a more secure value
    SECRET_KEY = 'your-secret-key'
    
    # Database configuration for Azure
    import os
    import urllib.parse
    
    db_url = os.environ.get('DATABASE_URL')
    if db_url:
        # Parse database URL
        db_url = urllib.parse.urlparse(db_url)
        DATABASES['default']['ENGINE'] = 'django.db.backends.postgresql'
        DATABASES['default']['NAME'] = db_url.path[1:]
        DATABASES['default']['USER'] = db_url.username
        DATABASES['default']['PASSWORD'] = db_url.password
        DATABASES['default']['HOST'] = db_url.hostname
        DATABASES['default']['PORT'] = db_url.port
    
    # Add your other production settings here

    在上面的配置中,我们禁用了调试模式,使用了一个更安全的秘钥,还配置了Azure数据库的连接。

    步骤 4:创建Azure Web应用

    现在,让我们在Azure上创建一个Web应用,以便托管我们的Django项目。你可以使用Azure CLI来完成这个任务。打开终端并执行以下命令:

    az webapp up --sku B1 --logs
    • --sku B1参数定义了应用服务计划的大小和成本。在本例中,我们使用的是B1(基本)服务计划,这将在Azure订阅中产生少量成本。你可以根据自己的需求选择其他服务计划。
    • --logs参数用于配置在启动Web应用程序后立即启用查看日志流所需的默认日志记录。

    运行上述命令后,它将自动创建所需的Azure资源,包括应用服务计划和Web应用。完成后,它会显示一个消息,其中包含你的应用程序的URL。你可以在浏览器中访问这个URL来查看你的Django应用程序。

    步骤 5:使用Django管理命令

    现在,你的Django应用程序已经在Azure上运行,接下来让我们看看如何使用Django的管理命令来执行各种任务。

    数据库迁移

    要在Azure上执行数据库迁移,可以使用以下命令:

    python manage.py migrate

    这将应用数据库迁移并创建或更新数据库中的表格。

    创建超级用户

    要创建一个超级用户

    ,可以使用以下命令:

    python manage.py createsuperuser

    然后按照提示输入用户名、电子邮件地址和密码。

    收集静态文件

    如果你的Django应用程序使用了静态文件(例如CSS、JavaScript文件等),需要收集它们以供生产使用。可以使用以下命令:

    python manage.py collectstatic

    这将把所有静态文件复制到一个统一的位置,以便在生产环境中提供访问。

    更多管理命令

    Django提供了许多其他管理命令,可以帮助你管理你的应用程序。你可以使用python manage.py help命令查看可用的管理命令列表,并使用python manage.py help <command>来获取关于特定命令的帮助。

    结尾

    恭喜你!你现在知道如何将Python Web应用程序部署到Azure并使用Django的管理命令来管理它。无论是配置设置、执行数据库迁移还是收集静态文件,Django的管理命令可以让你轻松管理你的Web应用。

    在云上托管你的应用程序可以为你提供更大的灵活性和可伸缩性,使你的应用程序能够随着需求的增长而扩展。希望这个教程对你有所帮助,祝你的Python Web应用在Azure上取得巨大成功!

  • 如何将Python Web应用部署到Azure应用服务

    如何将Python Web应用部署到Azure应用服务

    欢迎来到本教程!在这里,你将学习如何将你的Python Web应用(可以是Django或Flask)部署到Azure应用服务。Azure应用服务是一项完全托管的Web托管服务,支持在Linux服务器环境中托管的Python应用。让我们开始吧!

    示例应用程序

    在本教程中,我们将提供两种Python框架的示例应用程序:Flask和Django。你可以选择其中一种来继续。示例应用程序可从以下链接下载或克隆到本地工作站:

    要在本地运行示例应用程序,请按照以下步骤进行:

    Flask 示例

    1. 打开终端并进入应用程序文件夹:

      cd msdocs-python-flask-webapp-quickstart
    2. 为应用创建一个虚拟环境(virtual environment):

      python3 -m venv .venv
      source .venv/bin/activate  # 如果你使用的是Windows,请使用 .venv\Scripts\activate
    3. 安装应用程序的依赖项:

      pip install -r requirements.txt
    4. 运行应用:

      flask run
    5. 在Web浏览器中访问示例应用,地址为 http://localhost:5000。

    Django 示例

    1. 打开终端并进入应用程序文件夹:

      cd msdocs-python-django-webapp-quickstart
    2. 为应用创建一个虚拟环境(virtual environment):

      python3 -m venv .venv
      source .venv/bin/activate  # 如果你使用的是Windows,请使用 .venv\Scripts\activate
    3. 安装应用程序的依赖项:

      pip install -r requirements.txt
    4. 运行应用:

      python manage.py runserver
    5. 在Web浏览器中访问示例应用,地址为 http://localhost:8000。

    现在你已经成功在本地运行了示例应用程序,让我们继续将它部署到Azure应用服务。

    在Azure中创建Web应用

    要在Azure中托管你的应用程序,你需要创建一个Azure应用服务的Web应用。你可以使用多种方式来完成这个任务,包括Azure门户、VS Code、Azure命令行界面(CLI)等。

    使用Azure CLI创建Web应用

    首先,确保你已经安装了Azure CLI并登录到你的Azure帐户。

    使用Azure CLI的az webapp up命令可以在单个步骤中创建必需的资源并部署应用程序。运行以下命令:

    az webapp up --runtime PYTHON:3.9 --sku B1 --logs
    • --runtime参数指定应用程序使用的Python版本,这里我们选择Python 3.9。你可以运行az webapp list-runtimes --os linux --output table命令来查看所有可用的运行时版本。
    • --sku参数定义应用服务计划的大小(CPU和内存)以及成本。在本示例中,我们使用B1(基本)服务计划,这将在Azure订阅中产生少量成本。你可以查看应用服务定价页以获取完整的服务计划列表。
    • --logs标志配置了在启动Web应用后立即启用查看日志流所需的默认日志记录。

    该命令可能需要几分钟才能完成。完成后,它将提供一个URL,你可以在其中访问部署的应用程序。

    恭喜!你已经在Azure中成功创建了Web应用。现在,让我们将应用程序代码部署到Azure。

    将应用程序代码部署到Azure

    Azure应用服务支持多种将应用程序代码部署到Azure的方法,包括支持GitHub Actions和所有主要的CI/CD工具。在这里,我们将介绍如何从本地工作站将代码部署到Azure。

    使用VS Code部署

    在VS Code中,你可以使用Azure扩展包来进行部署。首先,确保你已经安装了Azure扩展包。

    1. 打开VS Code,并在应用程序文件夹中打开终端。

    2. 使用以下命令登录到Azure:

      az login
    3. 使用以下命令将应用程序代码部署到Azure:

      az webapp up --name  --runtime PYTHON:3.9 --sku B1 --logs
      • <app-name>是你的应用程序的名称,你可以选择一个名称或让Azure自动生成一个。

    这将自动创建所需的资源并部署你的应用程序。

    使用Azure CLI进行部署

    如果你喜欢使用命令行界面,你也可以使用Azure CLI将应用程序代码部署到Azure。

    1. 打开终端并进入应用程序文件夹。

    2. 使用以下命令登录到Azure:

      az login
    3. 使用以下命令将应用程序代码部署到Azure:

      
      az webapp up --name  --runtime PYTHON:3.

    9 –sku B1 –logs

    
       - <app-name>是你的应用程序的名称,你可以选择一个名称或让Azure自动生成一个。
    
    这将自动创建所需的资源并部署你的应用程序。
    
    ### 使用本地Git进行部署
    
    如果你使用本地Git仓库来管理你的应用程序代码,你也可以使用Git来将应用程序部署到Azure。
    
    1. 打开终端并进入应用程序文件夹。
    
    2. 使用以下命令将应用程序代码提交到本地Git仓库:
    
       ```bash
       git init
       git add .
       git commit -m "Initial commit"
    1. 使用以下命令将你的本地Git仓库关联到Azure应用服务:

      az webapp deployment source config-local-git --name  --resource-group 
      • <app-name>是你的应用程序的名称。
      • <resource-group-name>是你的Azure资源组的名称。
    2. 使用以下命令获取Git部署凭据:

      az webapp deployment list-publishing-credentials --name  --resource-group 
    3. 记下其中一个用户名和密码。

    4. 使用以下命令将你的代码推送到Azure应用服务:

      git remote add azure 
      git push azure master
      • <deployment-url>是你在步骤4中获取的Git部署URL。

    这将自动将你的应用程序代码部署到Azure。

    浏览应用

    现在,你的Python Web应用程序已成功部署到Azure应用服务。你可以在Web浏览器中使用以下URL访问已部署的应用程序:http://.azurewebsites.net。如果看到默认应用程序页面,请稍等片刻,然后刷新浏览器。

    恭喜!你已经成功将Python应用程序部署到Azure应用服务。现在你可以与全世界分享你的Web应用了!

    流式传输日志

    Azure应用服务会捕获已输出到控制台的所有消息,以帮助你诊断应用程序的问题。如果你的应用程序包含了print()语句或其他日志记录代码,你可以使用以下步骤查看日志:

    1. 使用Azure CLI配置Azure应用服务以将日志记录到文件系统:

      az webapp log config --web-server-logging filesystem --name  --resource-group 
      • <app-name>是你的应用程序的名称。
      • <resource-group-name>是你的Azure资源组的名称。
    2. 使用以下命令流式传输日志:

      az webapp log tail --name  --resource-group 

    刷新你的应用程序主页或尝试发出其他请求,以生成一些日志消息。你将看到类似下面的输出:

    Starting Live Log Stream ---
    
    2023-09-19T10:30:52.740703322Z Request for index page received
    2023-09-19T10:30:52.740740222Z 169.254.130.1 - - [19/Sep/2023:10:30:52 +0000] "GET / HTTP/1.1" 200 1360 "https://<app-name>.azurewebsites.net/hello" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0"
    2023-09-19T10:30:52.841043070Z 169.254.130.1 - - [19/Sep/2023:10:30:52 +0000] "GET /static/bootstrap/css/bootstrap.min.css HTTP/1.1" 200 0 "https://<app-name>.azurewebsites.net/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0"
    2023-09-19T10:30:52.884541951Z 169.254.130.1 - - [19/Sep/2023:10:30:52 +0000] "GET /static/images/azure-icon.svg HTTP/1.1" 200 0 "https://<app-name>.azurewebsites.net/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0"
    2023-09-19T10:30:53.043211176Z 169.254.130.1 - - [19/Sep/2023:10:30:53 +0000] "GET /favicon.ico HTTP/1.1" 404 232 "https://<app-name>.azurewebsites.net/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0"
    
    2023-09-19T10:31:01.304306845Z Request for hello page received with name=David
    2023-09-19T10:31:01.304335945Z 169.254.130.1 - - [19/Sep/2023:10:31:01 +0000] "POST /hello HTTP/1.1" 200 695 "https://<app-name>.azurewebsites.net/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0"
    2023-09-19T10:31:01.398399251Z 169.254.130.1 - - [19/Sep/2023:10:31:01 +0000] "GET /static/bootstrap/css/bootstrap.min.css HTTP/1.1" 304 0 "https://<app-name>.azurewebsites.net/hello" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0"
    2023-
    
    09-19T10:31:01.430740060Z 169.254.130.1 - - [19/Sep/2023:10:31:01 +0000] "GET /static/images/azure-icon.svg HTTP/1.1" 304 0 "https://<app-name>.azurewebsites.net/hello" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0"

    恭喜!你现在知道如何查看你的应用程序的日志以进行故障排除。

    清理资源

    在使用完本示例应用程序后,你可以从Azure中删除该应用的所有资源,以避免产生额外的费用并保持你的Azure订阅整洁。最快的方法是删除资源组,这将删除资源组中的所有资源。

    使用Azure CLI,你可以运行以下命令来删除资源组:

    az group delete --name <resource-group-name> --no-wait

    --no-wait参数允许命令在操作完成之前返回。


    恭喜你完成了本教程!现在你知道如何将Python Web应用程序部署到Azure应用服务。希望这个教程对你有所帮助!

  • 在VS Code中开始使用Python

    在VS Code中开始使用Python

    你好!在这篇教程中,你将学习如何在Visual Studio Code中使用Python 3创建、运行和调试一个Python“掷骰子”的应用程序,使用虚拟环境,使用包等等!通过使用Python扩展,你可以将VS Code变成一个出色的、轻量级的Python编辑器。

    如果你想了解更多关于Python语言的内容,可以在python.org上查看相关的编程教程,结合使用VS Code进行学习。

    先决条件

    要成功完成这个教程,你需要首先设置好Python开发环境。具体来说,这个教程需要:

    • Python 3
    • VS Code
    • VS Code Python扩展(有关安装扩展的详细信息,请参见扩展市场)

    安装Python解释器

    除了Python扩展,你还需要安装一个Python解释器。你使用哪个解释器取决于你的具体需求,但以下是一些建议。

    Windows

    从python.org安装Python。使用页面上首次出现的“Download Python”按钮来下载最新版本。

    *注意:如果你没有管理员权限,另一种在Windows上安装Python的选项是使用Microsoft Store。Microsoft Store提供了受支持的Python版本的安装。

    有关在Windows上使用Python的其他信息,请参阅Python.org上的“在Windows上使用Python”。

    macOS

    macOS上的系统安装的Python不受支持。相反,建议使用像Homebrew这样的包管理系统。要在macOS上使用Homebrew安装Python,请在终端提示符处输入brew install python3。

    *注意:在macOS上,请确保你的VS Code安装位置包含在你的PATH环境变量中。有关更多信息,请参见这些设置说明。

    Linux

    Linux上内置的Python 3安装效果很好,但要安装其他Python包,你必须使用get-pip.py安装pip。

    其他选项

    数据科学:如果你使用Python的主要目的是进行数据科学,那么可以考虑从Anaconda下载。Anaconda不仅提供Python解释器,还提供许多有用的数据科学库和工具。

    Windows子系统用于Linux:如果你在Windows上工作,并希望使用Python进行工作,可以选择使用Windows子系统用于Linux(WSL)。如果选择此选项,你还需要安装WSL扩展。有关在VS Code中使用WSL的更多信息,请参见VS Code远程开发或尝试“在WSL中工作”的教程,该教程将引导你完成设置WSL、安装Python和创建在WSL中运行的Hello World应用程序的过程。

    *注意:要验证你是否成功在计算机上安装了Python,请运行以下命令之一(根据你的操作系统而定):

    Linux/macOS:打开终端窗口,输入以下命令:

    python3 --version

    Windows:打开命令提示符,运行以下命令:

    py -3 --version

    如果安装成功,输出窗口应该显示你安装的Python版本。此外,你可以在VS Code集成终端中使用py -0命令查看计算机上安装的Python版本。默认解释器将被标识为一个星号(*)。

    在工作区文件夹中启动VS Code

    通过在一个文件夹中启动VS Code,该文件夹将成为你的“工作区”。

    使用命令提示符或终端,在一个名为“hello”的空文件夹中启动VS Code。可以通过输入以下命令来创建该文件夹,并在其中打开VS Code:

    mkdir hello
    cd hello
    code .

    *注意:如果你使用的是Anaconda发行版,请确保使用Anaconda命令提示符。

    另外,你也可以通过操作系统的UI创建一个文件夹,然后使用VS Code的“文件”>“打开文件夹”来打开项目文件夹。

    创建虚拟环境

    Python开发者的最佳实践之一是使用特定于项目的虚拟环境。一旦你激活了该环境,你安装的任何包都将与其他环境(包括全局解释器环境)隔离开,从而减少了由于冲突的包版本而引发的许多问题。你可以在VS Code中使用Venv或Anaconda来创建非全局环境。

    • 打开命令面板(Ctrl+Shift+P),开始键入“Python: Create Environment”命令来搜索,然后选择该命令。

    • 该命令会显示一个环境类型列表,即Venv或Conda。在本例中,选择Venv。

    • 然后,该命令会显示可以用于你的项目的解释器列表。选择你在教程开始时安装的解释器。

    • 选择解释器后,将显示一个通知,显示环境创建的进度,并在你的工作区中出现环境文件夹(/.venv)。

    • 使用命令面板中的“Python: Select Interpreter”命令,确保选择了新环境。

    *注意:有关虚拟环境的更多信息,或者如果在创建环境的过程中遇到错误,请参阅Environments。

    创建Python源代码文件

    在文件资源管理器工具栏中,选择“hello”文件夹上的“新建文件”按钮:

    • 以.py为扩展名命名文件,VS Code将自动在编辑器中打开它。

    通过使用.py文件扩展名,你告诉VS Code将这个文件解释为Python程序,因此它会使用Python扩展和选择的解释器来评估文件的内容。

    *注意:文件资源管理器工具栏还允许你在工

    作区内创建文件夹,以更好地组织你的代码。你可以使用“新建文件夹”按钮来快速创建文件夹。

    现在,你的工作区中有一个代码文件,可以在hello.py中输入以下源代码:

    msg = "Roll a dice"
    print(msg)

    当你开始输入print时,注意到智能感知提供了自动完成选项。

    智能感知适用于标准Python模块以及安装到所选Python解释器环境的其他包。它还提供了对象类型上可用的方法的完成。例如,因为msg变量包含一个字符串,所以当你输入msg.时,智能感知会提供字符串方法。

    最后,保存文件(Ctrl+S)。此时,你已经准备好在VS Code中运行你的第一个Python文件。

    有关编辑、格式化和重构的详细信息,请参阅Editing code。Python扩展还对Linting提供了全面支持。

    运行Hello World

    在编辑器右上角单击“在终端中运行Python文件”播放按钮。

    这个按钮会打开一个终端面板,在这个面板中,你的Python解释器会自动激活,然后运行python3 hello.py(macOS/Linux)或python hello.py(Windows):

    • 你还可以以其他三种方式在VS Code中运行Python代码:

    • 在编辑器窗口中的任何位置右键单击,然后选择“运行”>“在终端中运行Python文件”(这会自动保存文件):

    • 选择一个或多个行,然后按Shift+Enter或右键单击并选择“在Python终端中运行选择/行”。这个命令方便你测试文件的一部分。

    • 从命令面板(Ctrl+Shift+P)中选择“Python: Start REPL”命令,以打开当前选择的Python解释器的REPL终端。在REPL中,你可以逐行输入和运行代码。

    配置和运行调试器

    现在,让我们尝试调试我们的Hello World程序。

    首先,在hello.py的第2行上设置一个断点,方法是将光标放在print调用上,然后按F9。或者,单击编辑器左侧的装订线旁边的位置编号。当你设置一个断点时,装订线旁边会出现一个红色圆圈。

    接下来,按F5初始化调试器。因为这是你第一次调试这个文件,所以会从命令面板打开一个配置菜单,允许你选择打开文件时要使用的调试配置类型。

    选择“Python文件”,这是使用当前在编辑器中显示的文件以当前选定的Python解释器运行的配置。

    通过单击编辑器上的运行按钮旁边的下拉箭头,然后选择“在终端中调试Python文件”,启动调试器。

    调试器将在文件的第一个断点停止。当前行在左边缘显示为黄色箭头。如果此时查看“局部变量”窗口,你将看到现在定义的msg变量出现在“局部”窗格中。

    一个调试工具栏出现在顶部,从左到右依次是:继续(F5)、跳过(F10)、跟入(F11)、跳出(Shift+F11)、重新启动(Ctrl+Shift+F5)和停止(Shift+F5)。

    状态栏也会更改颜色(在许多主题中为橙色),表示你处于调试模式。Python调试控制台也会自动显示在右下角面板中,显示正在运行的命令以及程序输出。

    要继续运行程序,请选择调试工具栏上的继续命令(F5)。调试器将运行到程序结束。

    你还可以通过将鼠标悬停在代码上,例如变量,来查看调试信息。对于msg,将鼠标悬停在变量上会在变量上方显示字符串“Roll a dice!”。

    你还可以在Debug Console中使用变量。如果没有看到它,请在VS Code的右下角区域中选择Debug Console,或从…菜单中选择它。然后尝试逐行输入以下行,一个接一个,位于控制台底部的>提示符下:

    msg
    msg.capitalize()
    msg.split()

    再次选择调试工具栏上的蓝色“继续”按钮(或按F5)以运行程序到完成。如果切换回控制台,将显示“Roll a dice!”,并且一旦程序完成,VS Code将退出调试模式。

    如果重新启动调试器,调试器将再次停在第一个断点上。

    要在程序完成之前停止运行程序,请使用调试工具栏上的红色方形停止按钮(Shift+F5),或使用“运行”>“停止调试”菜单命令。

    对于完整的详细信息,请参阅Debugging configurations,其中包括如何在调试过程中使用特定的Python解释器的注意事项。

    提示:使用Logpoints而不是print语句:开发人员经常在源代码中散布print语句,以快速检查变量,而不一定要在调试器中逐行执行代码。在VS Code中,你可以使用Logpoints。Logpoint类似于断点,但它会将消息记录到控制台,并且不会停止程序。有关更多信息,请参阅主要的VS Code调试文章中的Logpoints。

    安装和使用包

    让我们通过使用包来构建上一个示例。

    在Python中,包是你获取任何数量有用

    的代码库的方式,通常从PyPI获得,它们为你的程序提供了额外的功能。对于这个示例,你可以使用numpy包来生成一个随机数。

    返回资源管理器视图(左侧最上方的图标,显示文件),打开hello.py,并粘贴以下源代码:

    import numpy as np
    
    msg = "Roll a dice"
    print(msg)
    
    print(np.random.randint(1,9))

    提示:如果你手动输入上述代码,你可能会发现,在关键字as后按Enter时,自动完成会更改名称。为了避免这种情况,输入一个空格,然后按Enter。

    接下来,使用上一节中描述的“Python: Current file”配置运行文件,可以选择使用或不使用调试器来查看输出!

    致谢: 此文章基于 Visual Studio Code 官方 Python 教程编写而成。

  • 重启WSL:解决问题的得力工具

    重启WSL:解决问题的得力工具

    你是否曾经在使用Windows Subsystem for Linux(WSL)时遇到过无法正常运行的应用程序或者需要实时更新的情况?别担心,WSL的重启可能是解决这些问题的有效方法。本教程将为你详细介绍如何重启WSL,以便顺利解决这些烦恼。

    引子:探索WSL的魅力

    在开始学习如何重启WSL之前,让我们简要了解一下WSL的魅力。

    WSL是一种在Windows操作系统上运行的类UNIX模拟环境,旨在让开发者能够在Windows上体验到流行的Unix/Linux开发环境。它允许用户使用大多数Linux命令,并能够运行许多Linux应用程序。然而,由于WSL是一个全新的环境,它可能会引发一些不可避免的问题,比如应用程序无法正常运行或需要实时更新。这时候,重启WSL可能是解决问题的好方法。

    步骤1:以管理员身份启动PowerShell

    首先,我们需要以管理员身份启动PowerShell。在Windows中,搜索“PowerShell”,然后右键单击它,并选择“以管理员身份运行”。

    步骤2:查看WSL信息

    在PowerShell中,输入以下命令来查看WSL信息:

    wsl -l -v

    这个命令将列出WSL版本以及安装的所有Linux子系统。示例输出如下:

    NAME      STATE    VERSION
    Ubuntu    Running  1
    Debian    Running  2

    步骤3:停止WSL

    要停止WSL系统,你可以使用以下命令:

    wsl --shutdown

    如果WSL成功停止,你将看到如下输出:

    WslRegisterDistribution failed with error: 0x80041002

    步骤4:启动WSL

    接下来,使用以下命令来启动WSL:

    wsl

    如果WSL成功重启,你将看到类似以下输出:

    To release /run/lock:
        systemctl status -.mount
        ...
        [OK] Reached target Remote File Systems
        [OK] Started Forward Password Requests to Wall Directory Watch.
        ...
        cinnamon-screensaver [2001]: Gdk-CRITICAL: gdk_x11_display_get_xdisplay: assertion 'GDK_IS_DISPLAY (display)' failed...
    
    #!/usr/bin/python3
    print("Hello, World!")

    步骤5:测试WSL

    最后,你可以使用以下命令来测试WSL是否成功重启:

    echo "Hello, WSL!"

    如果WSL成功重启,输出结果应该如下:

    Hello, WSL!

    结论

    通过以上步骤,你可以在PowerShell中使用wsl命令来重启WSL,以解决一些无法运行或需要实时更新的问题。需要注意的是,在执行重新启动WSL命令之前,请确保保存了在WSL中未完成的操作。

    现在,你已经学会了如何重启WSL,让你的开发环境更加稳定和高效。享受使用WSL的便利,并充分利用这个强大的工具来提高你的开发体验吧!

    有了以上的步骤和指南,你可以轻松地重启WSL,解决与WSL相关的各种问题,确保你的开发环境始终保持在最佳状态。现在,赶紧尝试一下,让WSL成为你开发工作的得力助手吧!

  • 生成随机字符串的Python教程

    生成随机字符串的Python教程

    你是否曾经需要生成随机字符串,无论是用于密码,测试数据,还是其他目的?这个简单的Python程序可以帮助你生成自定义长度和字符集的随机字符串。在本教程中,我们将介绍如何使用Python和Tkinter库创建一个交互式的随机字符串生成器。让我们开始吧!

    故事开篇

    假设你正在为一个新的在线账户创建一个密码,但你不确定应该选择什么密码。或者你正在进行软件测试,需要一些随机的测试数据。这时,一个随机字符串生成器会非常有用。这个生成器可以帮助你生成各种长度和字符集的随机字符串,满足你的需求。

    安装和设置

    首先,确保你的计算机上已经安装了Python。你可以从Python官方网站下载并安装最新版本的Python。

    接下来,我们需要安装Tkinter库,这是Python的标准GUI库,用于创建用户界面。大多数情况下,Tkinter已经包含在Python的安装中,所以你无需额外安装。如果你不确定是否已经安装了Tkinter,可以在终端或命令提示符中运行以下命令来检查:

    python -m tkinter

    如果看到Tkinter的信息,说明已经安装了Tkinter。

    现在,我们可以开始编写我们的随机字符串生成器程序了。

    创建随机字符串生成器

    我们将使用Python编写一个交互式的随机字符串生成器,并使用Tkinter库来创建用户界面。下面是完整的代码:

    import random
    import string
    import tkinter as tk
    
    # 函数 - 生成随机字符串
    def generate_random_string():
        try:
            length = int(entry_length.get())
            if length <= 0:
                label_result.config(text="错误:长度必须是正整数")
                return ""
        except ValueError:
            label_result.config(text="错误:请输入一个整数")
            return ""
    
        allowed_chars = ""
    
        if var_upper.get():
            allowed_chars += string.ascii_uppercase
        if var_lower.get():
            allowed_chars += string.ascii_lowercase
        if var_digit.get():
            allowed_chars += string.digits
        if var_punct.get():
            allowed_chars += string.punctuation
    
        if not allowed_chars:
            label_result.config(text="错误:请至少选择一种字符集")
            return ""
    
        random_string = "".join(random.choice(allowed_chars)
                                for _ in range(length))
    
        def has_duplicates(s):
            return len(s) != len(set(s))
    
        def replace_duplicates(s):
            new_s = ""
            for ch in s:
                if s.count(ch) > 1:
                    new_ch = random.choice(allowed_chars)
                    new_s += new_ch
                else:
                    new_s += ch
            return new_s
    
        def remove_duplicates(s):
            while has_duplicates(s):
                s = replace_duplicates(s)
            return s
    
        rs = remove_duplicates(random_string)
    
        return rs
    
    # 函数 - 显示并复制随机字符串
    def show_and_copy_random_string():
        random_string = generate_random_string()
    
        if random_string:
            label_result.config(text=random_string)
            window.clipboard_clear()
            window.clipboard_append(random_string)
    
    # 创建主窗口
    window = tk.Tk()
    window.title("随机字符串生成器")
    window.geometry("400x300")
    
    # 创建界面元素
    label_welcome = tk.Label(window, text="欢迎使用随机字符串生成器!")
    label_welcome.pack()
    
    label_length = tk.Label(window, text="请输入你想要生成的字符串长度(正整数):")
    label_length.pack()
    
    entry_length = tk.Entry(window)
    entry_length.pack()
    
    var_upper = tk.BooleanVar()
    var_lower = tk.BooleanVar()
    var_digit = tk.BooleanVar()
    var_punct = tk.BooleanVar()
    
    check_upper = tk.Checkbutton(window, text="大写字母", variable=var_upper)
    check_upper.pack()
    check_lower = tk.Checkbutton(window, text="小写字母", variable=var_lower)
    check_lower.pack()
    check_digit = tk.Checkbutton(window, text="数字", variable=var_digit)
    check_digit.pack()
    check_punct = tk.Checkbutton(window, text="特殊字符", variable=var_punct)
    check_punct.pack()
    
    button_generate = tk.Button(window, text="一键生成并复制",
                                command=show_and_copy_random_string)
    button_generate.pack()
    
    label_result = tk.Label(window, text="")
    label_result.pack()
    
    # 启动主循环
    window.mainloop()

    让我们一步一步解释这个代码。

    代码解释

    导入模块

    我们首先导入了所需的模块,包括random用于生成随机字符,string用于提供字符集,以及tkinter用于创建GUI界面。

    生成随机字符串函数

    generate_random_string函数是这个程序的核心。它负责生成随机字符串,并根据用户的选择确定字符集和长度。

    • 首先,我们尝试从用户输入中获取字符串长度,并检查是否为正整数。如果用户输入无效,将显示相应的错误消息。

    • 然后,我们根据用户选择的选项构建允许的字符集。

    • 如果用户未选择任何字符集,将显示错误消息。

    • 接下来,我们使用random.choice函数从允许的字符集中随机选择字符,并将它们连接成字符串,以满足用户指定的长度。

    • 最后,我们定义了三个辅助函数来处理生成的随机字符串:

      • has_duplicates检查字符串是否包含重复字符。
      • replace_duplicates替换字符串中的重复字符。
      • remove_duplicates使用replace_duplicates函数直到字符串中没有重复字符为止。

    显示并复制随机字符串函数

    show_and_copy_random_string函数负责生成随机字符串,显示它在界面上,并将其复制到剪贴板。

    创建用户界面

    我们使用Tkinter创建了一个用户界面,包括标签、文本框、复选框和按钮,以便用户可以自定义随机字符串的参数。

    • label_welcome显示欢

    迎消息。

    • label_length要求用户输入字符串长度。
    • entry_length允许用户输入字符串长度。
    • var_upper、var_lower、var_digit和var_punct是用于存储复选框状态的变量。
    • check_upper、check_lower、check_digit和check_punct是复选框,允许用户选择包含哪些字符集。
    • button_generate是生成随机字符串的按钮。
    • label_result用于显示随机生成的字符串或错误消息。

    启动主循环

    最后,我们使用window.mainloop()启动了Tkinter的主循环,使用户可以与界面交互。

    使用随机字符串生成器

    现在,你已经了解了代码的每个部分,让我们看看如何使用这个随机字符串生成器:

    1. 运行程序:运行Python脚本,界面将出现。
    2. 输入字符串长度:在文本框中输入你想要生成的字符串的长度(必须是正整数)。
    3. 选择字符集:选择你想要包含在随机字符串中的字符集,可以选择大写字母、小写字母、数字和特殊字符。
    4. 生成随机字符串:点击“一键生成并复制”按钮,程序将生成随机字符串并将其显示在界面上。
    5. 复制到剪贴板:生成的随机字符串已经复制到剪贴板,你可以粘贴到你需要的地方。

    结语

    通过这个简单的Python程序,你可以轻松地生成随机字符串,满足各种需求,从创建密码到生成测试数据都非常方便。希望这个教程对你有所帮助!

    如果你有任何问题或建议,都可以留下评论,我们会很乐意为你解答。

  • 制作一个透明时钟应用程序使用Python的Tkinter库

    制作一个透明时钟应用程序使用Python的Tkinter库

    你是否曾经想过制作一个独特的、透明度可调的时钟应用程序?通过使用Python的Tkinter库,你可以轻松实现这个目标。在本教程中,我将带你一步步创建一个透明时钟应用程序,具备透明度调整和字体大小设置功能。

    开篇故事

    想象一下,你正坐在一个时髦的咖啡馆里,周围的人们都在使用各种各样的时钟应用程序来追踪时间。但你想要的是一个与众不同的时钟应用程序,一个可以调整透明度的时钟,以及一个可以自定义字体大小的功能。你希望能够在工作时将时钟保持半透明,而在需要时可以将其变得更加清晰可见。现在,让我们一起制作这个独特的透明时钟应用程序吧!

    步骤1:导入必要的库

    首先,我们需要导入必要的库。我们将使用Tkinter来创建图形用户界面,使用time来跟踪时间,使用datetime来格式化时间,并使用font来管理字体。

    import tkinter as tk
    from tkinter import font
    import time
    from datetime import datetime

    步骤2:创建透明时钟类

    现在,让我们创建一个名为TransparentClock的类,该类将继承自Tkinter的Tk类。这个类将负责创建透明时钟窗口和处理时间更新等任务。

    class TransparentClock(tk.Tk):
        def __init__(self):
            super().__init__()
            self.attributes("-alpha", 0.8)  # 设置窗口透明度,取值范围为0.0(完全透明)到1.0(不透明)
            self.overrideredirect(True)
            self.label = tk.Label(self, font=("Arial", 24), fg="white", bg="black")
            self.label.pack(fill="both", expand=True)
            self.update_time()
            self.bind_events()

    在这个类中,我们设置了窗口的透明度和创建了一个标签来显示时间。我们还调用了update_time和bind_events方法,这些方法稍后将被定义。

    步骤3:更新时间

    我们需要一个方法来更新时钟上显示的时间。我们将使用update_time方法来实现这一点。

        def update_time(self):
            current_time = datetime.now().strftime("%H:%M:%S")
            self.label.config(text=current_time)
            self.after(1000, self.update_time)  # 每隔1秒钟更新时间显示

    update_time方法使用datetime.now()获取当前时间,然后将其格式化为小时:分钟:秒的形式,并将其显示在标签上。我们还使用after方法来实现每秒钟更新一次时间。

    步骤4:绑定事件

    我们希望能够拖动时钟窗口,以及通过右键点击来设置字体大小。为此,我们需要绑定事件处理方法。

        def bind_events(self):
            self.bind("<ButtonPress-1>", self.start_move)
            self.bind("<ButtonRelease-1>", self.stop_move)
            self.bind("<B1-Motion>", self.on_move)
            self.bind("<Button-3>", self.show_font_dialog)  # 监听鼠标右键,调用显示字体对话框

    在这里,我们绑定了鼠标左键点击、释放和拖动事件,以及鼠标右键点击事件。

    步骤5:移动窗口

    为了实现拖动窗口的功能,我们需要定义一些处理方法。

        def start_move(self, event):
            self._start_x = event.x
            self._start_y = event.y
    
        def stop_move(self, event):
            self._start_x = None
            self._start_y = None
    
        def on_move(self, event):
            deltax = event.x - self._start_x
            deltay = event.y - self._start_y
            x = self.winfo_x() + deltax
            y = self.winfo_y() + deltay
            self.geometry(f"+{x}+{y}")

    start_move方法记录了鼠标左键点击时的坐标,stop_move方法在释放左键时将这些坐标重置,而on_move方法计算了窗口应该移动的距离,并将窗口移动到新的位置。

    步骤6:显示字体对话框

    最后,我们需要添加一个方法来显示字体对话框,并允许用户选择字体大小。

        def show_font_dialog(self, event):
            dialog = FontDialog(self)
            self.wait_window(dialog.top)
            if dialog.result:
                font_size = dialog.result
                self.update_label_font(font_size)

    这个方法创建了一个FontDialog对话框,并等待用户关闭对话框。如果用户选择了字体大小,我们将调用update_label_font方法来更新标签的字体大小。

    步骤7:字体对话框类

    现在,让我们创建FontDialog类,用于显示字体大小设置对话框。

    class FontDialog(tk.Toplevel):
        def __init__(self, parent):
            super().__init__(parent)
            self.title("字体大小设置")
            self.result = None
    
            self.top = tk.Frame(self)
            self.top.pack(pady=10)
    
            self.font_size_var = tk.IntVar()
            self.font_size_var.set(72)
    
            self.slider = tk.Scale(self.top, from_=10, to=200, orient=tk.HORIZONTAL, variable=self.font_size_var)
            self.slider.pack(padx=20, pady=5)
    
            self.button_frame = tk.Frame(self)
            self.button_frame.pack(pady=10)
    
            self.ok_button = tk.Button(self.button_frame, text="确定", command=self.set_font_size)
            self.ok_button.pack(side=tk.LEFT, padx=5)
    
            self.cancel_button = tk.Button(self.button_frame, text="取消", command=self.cancel)
            self.cancel_button.pack(side=tk.LEFT)

    FontDialog类创建了一个窗口,其中包含一个滑块用于选择字体大小,以及确定和取消按钮。用户可以通过滑动滑块来选择字体大小,然后点击确定或取消按钮。

    步骤8:更新字体大小

    最后,我们需要添加方法来更新标签的字体大小。

        def update_label_font(self, size):
            current_font = self.label['font']
            font_name = font.Font(font=current_font).actual()['family']
            self.label.configure(font=(font_name, size))

    update_label_font方法获取当前标签的字体和字体名称,然后使用用户选择的字体大小更新标签的字体。

    步骤9:运行应用程序

    最后,让我们在if __name__ == "__main__":块中运行应用程序。

    if __name__ == "__main__":
        app = TransparentClock()
        app.mainloop()

    现在,你可以运行这个应用程序,看看你创建的透明时钟应用程序是否能正常工作。

    结论

    通过本教程,你学会了如何使用Python的Tkinter库创建一个独特的透明时钟应用程序。你可以轻松拖动窗口、调整透明度,并根据自己的喜好设置字体大小。这个应用程序不仅实用,而且也很有趣,适合用来装点你的桌面。

    现在,你可以尝试自己进行更多的定制,如更改背景颜色、字体颜色等,以使时钟更符合你的品味。

    希望你喜欢这个教程,享受制作自己的透明时钟应用程序的过程!

  • 如何使用Python自动获取Steam限时免费游戏信息并推送通知

    如何使用Python自动获取Steam限时免费游戏信息并推送通知

    你是否是一位游戏爱好者,经常关注Steam上的限时免费游戏活动?如果是的话,你可能会发现每天都需要手动查看这些游戏信息,以确保不错过任何一个免费游戏的机会。但是,有没有一种方法可以让你自动获取这些信息并及时通知你呢?答案是肯定的!在本教程中,我们将介绍如何使用Python编写一个自动获取Steam限时免费游戏信息并通过推送通知告诉你的工具。

    故事开头

    你是一名热衷于游戏的玩家,每天都会关注Steam上的限时免费游戏活动。然而,由于工作繁忙,你经常会错过这些免费游戏的机会。你曾经试图使用提醒功能,但发现它并不是特别方便,因为你需要手动设置提醒时间并确保不错过。因此,你决定寻找一种更智能的方式来获取这些信息,以便在游戏免费时能够第一时间得知。

    准备工作

    在开始编写自动获取Steam限时免费游戏信息的工具之前,你需要准备以下几个要素:

    1. Python环境: 确保你已经安装了Python,并且可以在你的计算机上运行Python程序。

    2. 必要的库: 本教程中使用了requests和BeautifulSoup库来进行网页爬取和解析,以及用于发送推送通知的功能。你需要确保这些库已经安装在你的Python环境中。

    3. 推送通知平台: 你需要选择一个推送通知平台,本教程中使用的是PushPlus。你需要在PushPlus上注册账户并获取一个用于发送通知的Token。

    4. Steam限时免费游戏页面: 你需要知道Steam限时免费游戏信息所在的页面URL。在本例中,我们使用的是steamstats.cn提供的页面。

    编写自动获取游戏信息工具

    发送推送通知

    首先,我们来编写一个函数,用于发送推送通知。在本教程中,我们使用了PushPlus来发送通知。你需要替换下面代码中的token为你在PushPlus上获取的Token。

    def pushplus(_item, _message):
        token = 'your_token_here'  # 替换为你的PushPlus Token
        api = 'http://www.pushplus.plus/send'
        _d = {
            "token": token,
            "title": _item,
            "content": _message
        }
        req = requests.post(api, data=_d)
        #print(req.text)

    网页爬取和信息提取

    接下来,我们需要编写代码来进行网页爬取和信息提取。我们使用requests库来获取网页内容,使用BeautifulSoup库来解析HTML。

    url = 'https://steamstats.cn/xi'
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.72 Safari/537.36 Edg/90.0.818.41'
    }
    
    r = requests.get(url, headers=headers)
    r.raise_for_status()
    r.encoding = r.apparent_encoding
    soup = BeautifulSoup(r.text, "html.parser")

    解析游戏信息

    现在,我们需要解析网页中的游戏信息。在Steam限时免费游戏页面上,游戏信息通常在tbody标签中。我们使用BeautifulSoup来查找并提取这些信息。

    tbody = soup.find('tbody')
    desp = "? 当前可领限时免费游戏 ?" + '\n'
    if tbody is not None:
        tr = tbody.find_all('tr')
        i = 1
        for tr in tr:
            # 提取游戏信息
            # ...(省略其他代码)
            desp = desp + "序号:" + str(i) + '\n' + "游戏名称:" + name + '\n' + "类型:" + gametype + '\n' + "开始时间:" + start + '\n' + "结束时间:" + end + '\n' + "是否永久:" + time + '\n' + "平台:" + oringin + '\n' + "链接:" + http + '\n'
            i = i + 1
        else:
            desp = desp + "无"

    发送推送通知

    最后,我们将获取的游戏信息发送到我们之前编写的pushplus函数,以便通过PushPlus发送通知。

    pushplus("? 今日喜加一 ?", desp)

    结束语

    通过本教程,你已经学会了如何使用Python编写一个自动获取Steam限时免费游戏信息并通过PushPlus推送通知的工具。这个工具可以帮助你及时获取最新的游戏信息,确保不错过任何一个免费游戏的机会。

    如果你对Python编程和自动化任务有更多的兴趣,不妨深入学习,探索更多有趣的应用领域!

    现在,你已经了解如何编写一个自动获取Steam限时免费游戏信息的工具了。希望这个教程对你有所帮助,让你在游戏世界中更加便捷和智能!

  • 如何使用Python编写一个自动抢码工具

    如何使用Python编写一个自动抢码工具

    你是否曾经想过如何利用编程技能来自动化一些重复性任务?或者是否曾经想过如何编写一个程序,能够在特定条件下执行某些操作?如果你是一名编程爱好者,那么你来对地方了!在本教程中,我们将介绍如何使用Python编写一个自动抢码工具,以帮助你在特定场景下完成自动化任务。无论是抢购热门商品、自动化游戏任务还是其他需要快速响应的情况,这个工具都能派上用场。

    故事开头

    假设你是一名玩家,热衷于某款热门游戏。游戏中有一项活动,需要扫描游戏中的二维码进行抢码操作,以获得珍贵的奖励。然而,这个活动的二维码每次都在不同的位置出现,手动扫描非常不方便,而且容易错过。于是,你决定使用自己的编程技能来解决这个问题,编写一个自动抢码工具,让你轻松抢到奖励。

    准备工作

    在开始编写自动抢码工具之前,你需要准备以下几个要素:

    1. Python环境: 确保你已经安装了Python,并且可以在你的计算机上运行Python程序。

    2. 必要的库: 本教程中使用了许多Python库,包括cv2(用于图像处理)、pyzbar(用于二维码识别)、http.client(用于网络请求)、tkinter(用于创建窗口界面)等。你需要确保这些库已经安装在你的Python环境中。

    3. 米游社账户: 你需要一个米游社账户,以便在游戏中进行抢码操作。确保你已经登录米游社,并且知道自己的UID和Cookie信息。

    4. 游戏类型和设备信息: 确定你要抢码的游戏类型(在本例中为4,表示某款游戏),以及生成一个唯一的设备标识符。

    编写自动抢码工具

    创建一个Tkinter窗口

    首先,我们将创建一个Tkinter窗口,这个窗口将用于显示屏幕截图以及识别到的二维码。这个窗口将始终保持在屏幕最前方,不会干扰你的操作。

    # 创建一个Tkinter窗口
    root = tk.Tk()
    # 隐藏窗口标题栏和边框
    root.overrideredirect(True)
    # 将窗口置顶
    root.wm_attributes("-topmost", True)
    # 设置窗口大小和位置
    win_width = 300
    win_height = 300
    screen_width = root.winfo_screenwidth()
    screen_height = root.winfo_screenheight()
    x_pos = (screen_width // 2) - (win_width // 2)
    y_pos = (screen_height // 2) - (win_height // 2)
    root.geometry('{}x{}+{}+{}'.format(win_width, win_height, x_pos, y_pos))
    # 将窗口背景设为透明
    root.attributes('-transparentcolor', 'white')
    # 将窗口的画布设为透明
    canvas = tk.Canvas(root, bg='white', highlightthickness=0)
    canvas.pack(fill='both', expand=True)
    # 绘制一个红色空心正方形
    canvas.create_rectangle(
        5, 5, win_width-5, win_height-5, outline='red', width=2)
    # 进入循环让窗口保持打开状态
    root.mainloop()

    设置扫描区域

    我们需要确定在屏幕上哪个区域进行二维码扫描。在这个例子中,我们将屏幕分成一个300×300的区域,用于扫描。

    # 设置扫描区域
    width, height = 300, 300
    # 获取屏幕尺寸
    screen_width = tk.Tk().winfo_screenwidth()
    screen_height = tk.Tk().winfo_screenheight()
    # 计算识别区域左上角
    left = (screen_width - width) // 2
    top = (screen_height - height) // 2
    # 计算识别区右下角
    right = left + width
    bottom = top + height

    截取屏幕截图

    编写一个函数来截取指定区域的屏幕截图,并将其转换为灰度图像。这个函数将会在后续的识别过程中使用。

    def capture_screen():
        saveDC = dc.CreateCompatibleDC()
    
        # 创建位图对象
        saveBitMap = win32ui.CreateBitmap()
        saveBitMap.CreateCompatibleBitmap(dc, right-left, bottom-top)
    
        # 将位图选入到DC中
        saveDC.SelectObject(saveBitMap)
    
        # 截屏并保存到位图中
        saveDC.BitBlt((0, 0), (right-left, bottom-top),
                      dc, (left, top), win32con.SRCCOPY)
    
        # 将位图对象转换为numpy数组并进行颜色空间转换
        bmpinfo = saveBitMap.GetInfo()
        bmpstr = saveBitMap.GetBitmapBits(True)
        screenshot = np.frombuffer(bmpstr, dtype='uint8').reshape(
            (bmpinfo['bmHeight'], bmpinfo['bmWidth'], 4))[:, :, :3]
        screenshot = cv2.cvtColor(screenshot, cv2.COLOR_BGR2GRAY)
    
        # 释放资源
        saveDC.DeleteDC()
        win32gui.DeleteObject(saveBitMap.GetHandle())
    
        return screenshot

    识别二维码

    使用pyzbar库来

    识别屏幕截图中的二维码。如果成功识别到二维码,我们将进一步处理它。

    # 截取屏幕截图
    screenshot = capture_screen()
    # 尝试使用pyzbar库识别二维码
    codes = decode(screenshot, symbols=[pyzbar.ZBarSymbol.QRCODE])
    
    # 如果找到了二维码,输出其内容
    if codes:
        print("扫码成功!")
        pattern = r"ticket=([a-f0-9]+)"
        match = re.search(pattern, codes[0].data.decode())
        # 正则请求地址
        if match:
            print(match.group(1))
            # 进入抢码
            start_time = time.time()
            retcode = Request(match.group(1))
            end_time = time.time()
            if retcode == 0:
                # 计算代码执行时间并输出
                elapsed_time = end_time - start_time
                print("抢码成功耗时 %.3f 秒" % elapsed_time)
                random = 1.3
                time.sleep(random)
                print("防止过快被察觉插入随机延迟")
                # 确认登陆
                start_time = time.time()
                ConfirmRequest(match.group(1))
                end_time = time.time()
                # 计算代码执行时间并输出
                elapsed_time = end_time - start_time
                print("确认登陆成功耗时 %.3f 秒" % elapsed_time)
                # print("作者by:吾爱破解tseed")
                # 等待一下
                time.sleep(1)
        else:
            print("未知二维码抢码失败")
            # 等待一下
            time.sleep(1)

    记录FPS和退出

    最后,我们可以记录每秒的帧数,并在按下键盘上的任意键时退出程序。

    # 记录每秒帧数
    frame_count = 0
    frame_start_time = time.time()
    while True:
        # ...(省略其他代码)
    
        # 记录每秒帧数
        frame_count += 1
        if time.time() - frame_start_time >= 1:
            fps = frame_count
            print(f"FPS:{fps}" + "\r", end='', flush=True)
            frame_count = 0
            frame_start_time = time.time()
    
        # 在窗口中显示截图
        cv2.imshow("QR Code Scanner", screenshot)
    
        # 检查是否按下了键盘上的任意键
        if cv2.waitKey(1) != -1:
            break
    # 关闭窗口
    cv2.destroyAllWindows()

    结束语

    通过本教程,你已经学会了如何使用Python编写一个自动抢码工具。这个工具可以用于各种需要自动化的场景,只需稍微调整代码即可。希望这个教程能帮助你更好地理解Python编程和自动化任务的原理,同时也能让你在特定情况下提高工作效率。

    如果你对Python编程和自动化有更多的兴趣,不妨深入学习,探索更多有趣的应用领域!

  • 在Azure虚拟机上搭建GPU PyTorch环境的完整指南

    在Azure虚拟机上搭建GPU PyTorch环境的完整指南

    你好!欢迎来到本教程,我们将一步一步教你如何在Azure虚拟机上搭建一个强大的GPU PyTorch环境,以便进行深度学习任务。在这个教程中,我们将涵盖以下主题:

    1. 引言

    在深度学习和机器学习中,GPU是必不可少的工具,它可以大大加速训练过程。在Azure虚拟机上搭建GPU PyTorch环境可以让你利用云计算的强大性能来进行深度学习任务,而不必购买昂贵的硬件。

    2. 想定的硬件和操作系统环境

    在开始之前,让我们先了解一下我们的想定硬件和操作系统环境:

    • 虚拟机型号:Standard_NC4as_T4_v3
    • 操作系统:Ubuntu 20.04 x64 Gen2
    • GPU:NVIDIA Tesla T4
    • CUDA版本:11.6

    请注意,本教程中的步骤是针对上述硬件和环境进行的,如果你的环境不同,可能需要做一些调整。

    3. 使用之前检查GPU信息

    在开始安装之前,让我们首先检查一下你的GPU信息,确保你的虚拟机中有NVIDIA GPU。

    $ lspci | grep -i nvidia

    如果一切正常,你应该会看到类似以下的输出:

    0001:00:00.0 3D controller: NVIDIA Corporation TU104GL [Tesla T4] (rev a1)

    接下来,我们可以检查当前系统中是否已经安装了NVIDIA驱动和CUDA。

    $ dpkg -l | grep nvidia
    $ dpkg -l | grep cuda

    如果已经安装了其他版本的驱动或CUDA,我们将在后面的步骤中进行卸载。

    4. 卸载现有的CUDA和NVIDIA驱动

    为了避免版本冲突,我们需要卸载当前系统中可能存在的CUDA和NVIDIA驱动。

    $ sudo apt-get --purge remove nvidia-*
    $ sudo apt-get --purge remove cuda-*

    这将卸载系统中的所有NVIDIA驱动和CUDA版本。

    5. 安装NVIDIA驱动

    接下来,我们将安装适用于我们的GPU的NVIDIA驱动。首先,让我们查找适合的驱动版本。

    $ sudo apt install ubuntu-drivers-common
    $ sudo ubuntu-drivers devices

    从输出中,找到标记为“recommended”的NVIDIA驱动版本,例如“nvidia-driver-525”,然后进行安装。

    $ sudo add-apt-repository ppa:graphics-drivers/ppa
    $ sudo apt update
    $ sudo apt install nvidia-driver-525

    完成安装后,重新启动虚拟机。

    $ sudo reboot

    重新登录后,你可以使用以下命令来验证NVIDIA驱动是否成功安装。

    $ nvidia-smi

    如果一切正常,你将看到与你的GPU相关的信息。

    6. 安装CUDA

    现在,让我们安装CUDA,这是深度学习中必不可少的库。首先,我们需要从NVIDIA官网获取适合我们的CUDA安装命令。选择正确的CUDA版本和操作系统,然后执行以下命令。

    $ wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/cuda-ubuntu2004.pin
    $ sudo mv cuda-ubuntu2004.pin /etc/apt/preferences.d/cuda-repository-pin-600
    $ wget https://developer.download.nvidia.com/compute/cuda/11.6.0/local_installers/cuda-repo-ubuntu2004-11-6-local_11.6.0-510.39.01-1_amd64.deb
    $ sudo dpkg -i cuda-repo-ubuntu2004-11-6-local_11.6.0-510.39.01-1_amd64.deb
    $ sudo apt-key add /var/cuda-repo-ubuntu2004-11-6-local/7fa2af80.pub
    $ sudo apt-get update
    $ sudo apt-get -y install cuda-11-6

    完成安装后,需要将CUDA的路径添加到环境变量中。编辑你的.bashrc文件并添加以下行:

    export PATH="/usr/local/cuda/bin:$PATH"
    export LD_LIBRARY_PATH="/usr/local/cuda/lib64:$LD_LIBRARY_PATH"

    然后使用以下命令使更改生效:

    $ source ~/.bashrc

    7. 安装cuDNN

    cuDNN是一个用于深度学习的GPU加速库,让我们来安装它。首先,你需要从NVIDIA官方网站下载cuDNN的安装包。你需要注册并登录以获取下载权限。

    下载完安装包后,将它传输到你的虚拟机上,然后执行以下步骤:

    $ sudo dpkg -i cudnn-local-repo-ubuntu2004-8.7.0.84_1.0-1_amd64.deb
    $ sudo cp /var/cudnn-local-repo-ubuntu2004-8.7.0.84/cudnn-local-A3837CDF-keyring.gpg /usr/share/keyrings/
    $ cd /var/cudnn-local-repo-ubuntu2004-8.7.0.84/
    $ sudo dpkg -i libcudnn8_8.7.0.84-1+cuda11.8_amd64.deb
    $ sudo dpkg -i libcudnn8-dev_8.7.0.84-1+cuda11.8_amd64.deb
    $ sudo dpkg -i libcudnn8-samples_8.7.0.84-1+cuda11.8_amd64.deb

    请确保按照上述顺序执行所有

    步骤,以防止出现错误。

    8. 验证cuDNN

    现在,让我们验证cuDNN是否已经成功安装。首先,重新启动你的虚拟机以确保所有更改生效。

    $ sudo reboot

    再次登录虚拟机并激活之前创建的conda环境(如果你使用的是conda)。

    $ conda activate torch

    接下来,运行Python并执行以下命令来验证cuDNN:

    import torch
    torch.cuda.is_available()  # 检查CUDA是否可用
    torch.cuda.device_count()    # 查看可用的GPU数量

    如果一切正常,你将看到CUDA可用,并且你的GPU数量。

    9. 安装PyTorch

    最后,让我们安装PyTorch,这是深度学习的核心库之一。你可以根据你的需求选择不同的PyTorch版本和安装命令。你可以在PyTorch官方网站上获取适合你的版本和命令。

    执行以下命令来安装PyTorch(请注意,这是一个示例命令,你应该根据你的需求选择正确的版本):

    $ pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu116

    10. 结束语

    恭喜你,你已经成功在Azure虚拟机上搭建了一个强大的GPU PyTorch环境!现在你可以开始进行深度学习任务了。请记住,本教程中的步骤是根据特定硬件和环境定制的,如果你的环境有所不同,可能需要做一些适应性调整。

    希望这个教程对你有所帮助,祝你在深度学习的旅程中取得成功!