Python

Общие ссылки Python

  • Официальный Python

    Преимущества Python

    Краткий и простой в освоении синтаксис

    Синтаксис Python прост и близок к естественному языку. Даже начинающие программисты могут быстро приступить к работе, снизив порог обучения.

    Богатая стандартная библиотека и сторонние ресурсы.

    Python предоставляет широкий спектр стандартных библиотек функций, охватывающих многие аспекты, такие как работа в сети, обработка данных и графические интерфейсы. Кроме того, мощная сторонняя экосистема, такая как NumPy, Pandas и TensorFlow, делает Python универсальным инструментом разработки.

    Кроссплатформенные функции

    Python — кроссплатформенный язык. Будь то Windows, macOS или Linux, можно выполнить одну и ту же программу Python, что значительно повышает гибкость разработки.

    Широко используется во многих областях

    Python играет важную роль во многих областях, таких как наука о данных, искусственный интеллект, веб-разработка, создание сценариев автоматизации, разработка игр и т. д., позволяя разработчикам решать множество задач с помощью одного языка.

    Активная поддержка сообщества

    Python имеет большое глобальное сообщество, и как новички, так и опытные разработчики могут легко найти образовательные ресурсы, дискуссионные группы и техническую поддержку.

    Эффективная скорость разработки

    Python предоставляет интуитивно понятный синтаксис и мощные инструменты, позволяющие разработчикам быстрее реализовывать программирование и сокращать цикл разработки продукта.

    Среда разработки Python

    Anaconda

    Что такое Анаконда?

    Anaconda — это платформа программирования на Python и R с открытым исходным кодом, предназначенная для научных вычислений, включая такие приложения, как обработка данных, машинное обучение, искусственный интеллект и анализ больших данных.

    Основные функции

    Подходит для объектов

    Anaconda подходит для пользователей в следующих сферах:

    Как установить Анаконду?

    1. доступОфициальный сайт Анаконды。
    2. Выберите подходящую версию операционной системы и загрузите соответствующий установочный файл.
    3. Следуйте инструкциям мастера установки, чтобы завершить установку и настроить переменные среды (необязательно).

    Часто задаваемые вопросы

    Ниже приведены проблемы, с которыми часто сталкиваются пользователи:

    Окружающая среда Анаконды

    Что такое среда Анаконды

    Anaconda предоставляет функцию виртуальной среды (Environment), которая позволяет пользователям создавать несколько независимых сред выполнения Python на одном компьютере. Каждая среда может иметь разные версии и пакеты Python, чтобы избежать конфликтов зависимостей между разными проектами.

    Создать среду

    # Создайте среду с именем myenv и укажите версию Python
conda create -n myenv python=3.10

    Запуск и переключение сред

    # Стартовая среда
Конда активирует myenv

#Выходим из окружения
Конда деактивировать

    Посмотреть среду

    # Список всех сред
список окружения Конды
# или
информация конды --envs

    Экспорт и восстановление сред

    # Экспорт конфигурации среды в файл YAML
экспорт env conda > Environment.yml

# Создать среду из файла YAML
conda env create -f Environment.yml

    Удалить среду

    # Удалить указанную среду
conda удалить -n myenv --all

    Jupyter

    Что такое Юпитер?

    Jupyter — это интерактивная вычислительная среда с открытым исходным кодом, которая поддерживает несколько языков программирования и в основном используется для анализа данных, машинного обучения и академических исследований.

  • Jupyter

    Основные функции

    Основные компоненты

    Область применения

    Jupyter широко используется в следующих областях:

    Как использовать Юпитер?

    1. Установите Anaconda или установите Jupyter автономно.
    2. Войдите в терминалjupyter notebookЗапустите блокнот Jupyter.
    3. Войдите в интерфейс редактирования через браузер, чтобы создавать и запускать блокноты.

    Преимущества и проблемы

    Среда разработки VS Code Python

    Установить код Visual Studio

    Перейти кОфициальный сайт кода Visual Studio, загрузите и установите версию, подходящую для вашей операционной системы.

    Установите расширение Python

    В Visual Studio Code установите расширение Python, выполнив следующие действия:

    1. Нажмите значок расширения слева.
    2. Найдите «Питон».
    3. Выберите расширение Python, предоставленное Microsoft, и нажмите «Установить».

    Установить Python

    Убедитесь, что Python установлен в вашей системе. Можно получить изОфициальный сайт PythonЗагрузите и установите.

    После завершения установки введите следующую команду в командной строке, чтобы подтвердить успешность установки:

    питон --версия
# или
python3 --версия

    Настройка интерпретатора Python

    Откройте проект или файл Python, щелкните строку состояния «Python» в правом нижнем углу кода Visual Studio и выберите соответствующий интерпретатор Python.

    Выполнить программу Python

    Откройте файл Python в редакторе и запустите программу, используя следующий метод:

    1. Щелкните правой кнопкой мыши содержимое файла и выберите «Запустить файл Python в терминале».
    2. Или используйте сочетания клавишCtrl + Shift + P, найдите «Запустить файл Python» и выполните его.

    Установите необходимые пакеты

    Если вам необходимо установить сторонний пакет, вы можете использовать встроенный терминал для ввода:

    имя пакета установки pip

    Включить автозаполнение и отладку

    Наслаждайтесь автозаполнением и мощными инструментами отладки благодаря функциональности, предоставляемой расширениями Python:

    1. Нажмите значок отладки слева.
    2. Выберите «Создать файл launch.json» и выберите Python.
    3. После завершения настроек нажмите F5, чтобы включить режим отладки.

    Часто используемые сочетания клавиш

    Вот некоторые часто используемые сочетания клавиш:

    VS Code

  • vscode/Vidual Studio Code

    VS Code устанавливает параметры выполнения Python

    Изменить файл запуска.json

    Если вам нужно передать параметры при выполнении программы Python, вы можете установитьlaunch.jsonЗаканчивать:

    1. Нажмите значок «Запуск и отладка» слева.
    2. Нажмите «Создать файл launch.json» или «Добавить конфигурацию».
    3. Выберите «Python» в качестве среды.
    4. в сгенерированныхlaunch.jsonИзмените соответствующие настройки в файле.

    Установите параметры программы и аргументов

    Ниже приведен пример конфигурации, включая путь к программе и параметры выполнения:

    {
    "версия": "0.2.0",
    "конфигурации": [
        {
            "name": "Python: запуск с аргументами",
            "тип": "питон",
            "запрос": "запуск",
            "program": "${workspaceFolder}/main.py", // путь к программе
            "console": "integratedTerminal", // тип терминала
            "args": ["arg1", "arg2", "--option", "value"] // Передаем параметры
        }
    ]
}

    Цель аргументов

    существоватьargsПараметры командной строки могут быть переданы, например:

    Чтение параметров в программе

    использоватьsys.argvЧтобы прочитать параметры, переданные из командной строки:

    импортсистем

print("Все параметры:", sys.argv)
если len(sys.argv) > 1:
    print("Первый параметр:", sys.argv[1])
    print("Второй параметр:", sys.argv[2])

    Пример выполнения

    Предположим, что программа:

    python main.py arg1 arg2 --option value

    Результат выполнения:

    Все параметры: ['main.py', 'arg1', 'arg2', '--option', 'value']
Первый параметр: arg1
Второй параметр: arg2

    Режим отладки VS Code Python

    Включить режим отладки

    1. УстановкаPython ExtensionРасширение.

    2. Запустите проект Python в VS Code.

    3. НажмитеF5Или нажмите на панель действий слева.Debugикона.

    Настройка launch.json

    1. Нажмите «Добавить конфигурацию» на панели «Отладка».

    2. ВыберитеPython, система автоматически создастlaunch.json。

    {
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Python: Current File",
            "type": "python",
            "request": "launch",
            "program": "${file}",
            "console": "integratedTerminal"
        }
    ]
}

    Установить точку останова

    1. Нажмите рядом с номером строки кода, чтобы добавить точку останова.

    2. Можно использовать условные точки останова: щелкните точку останова правой кнопкой мыши и выберите «Редактировать условие».

    Функция отладки

    Проверьте переменные

    1. Просмотрите текущий статус переменной в области «Переменные» панели «Отладка».

    2. Вы можете вручную добавить определенные выражения в область «Мониторинг».

    Использование консоли отладки

    1. Введите команды Python в консоли отладки, чтобы проверить состояние программы в режиме реального времени.

    2. Может выполнять такие операции, как запрос переменных и вызов функций.

    VS Code устанавливает путь Python

    Шаг 1. Установите Python и VS Code

    Убедитесь, что Python установлен и добавлен в переменные среды вашей системы, затем загрузите и установите Visual Studio Code.

    Шаг 2. Установите расширение Python

    Откройте код Visual Studio, щелкните значок «Расширения» слева и выполните поиск.Python, а затем установите расширения Python, предоставленные Microsoft.

    Шаг 3. Проверьте путь установки Python.

    Введите следующую команду в терминале, чтобы подтвердить путь установки Python:

    which python

    Или (система Windows):

    where python

    Шаг 4. Установите путь Python

    В коде Visual Studio нажмитеCtrl + Shift + P, введите и выберитеPython: Select Interpreter。

    Выберите правильный путь Python в манифесте. Если он не отображается, введите полный путь вручную.

    Шаг 5. Подтвердите настройки.

    Откройте терминал и выполнитеpython --versionчтобы подтвердить, что выбрана правильная версия интерпретатора Python.

    Дополнительная информация

    Если вам нужен путь Python к конкретному проекту, вы можете добавить его в корневой каталог проекта..vscode/settings.jsonфайл и добавьте следующий контент:

    {
  "python.pythonPath": "Ваш полный путь к Python"
}

    заменятьПолный путь к вашему Pythonэто реальный путь.

    Переключение среды VS Code Python

    При разработке в VS Code я решаю использовать Anaconda или другие среды, в основном через настройки базового интерпретатора (Интерпретатора). Это гарантирует полную изоляцию зависимостей вашего пакета от среды выполнения программы.

    1. Шаги по выбору среды Python

    2. Как решить использовать Anaconda или другие среды

    тип среды Применимые ситуации Основные преимущества
    Anaconda Наука о данных, машинное обучение, глубокое обучение Он предварительно установлен с большим количеством библиотек научных вычислений и обеспечивает надежное управление базовыми двоичными файлами (такими как DLL).
    Venv Общая веб-разработка, скрипты автоматизации Легкий, быстро запускается и содержит только необходимые для выполнения пакеты.

    3. Управление средами и их переключение в Conda.

    Помимо графического интерфейса, для управления средой вы также можете использовать команды встроенного терминала VS Code:

    4. Часто задаваемые вопросы и решения

    Запустите Python на своем Chromebook

    Способ 1: использование Linux (Кростини)

    1. Включите «Linux (бета)» или «Разработчик → Среда разработки Linux» в настройках Chromebook.
    2. Запустите терминал Linux и введите:
      
sudo apt update
sudo apt install python3 python3-pip -y
    3. входитьpython3Войдите в интерактивную среду Python.
    4. Для установки дополнительных модулей доступныимя модуля установки pip3。

    Способ 2. Используйте онлайн-компилятор.

    Способ 3. Установите приложение для Android.

    Способ 4: используйте код VS

    1. Установите VS Code в среде Linux (Crostini):
      
sudo apt install wget gpg -y
wget -qO- https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > packages.microsoft.gpg
sudo install -o root -g root -m 644 packages.microsoft.gpg /usr/share/keyrings/
sudo sh -c 'echo "deb [arch=amd64 signed-by=/usr/share/keyrings/packages.microsoft.gpg] \
https://packages.microsoft.com/repos/code stable main" > /etc/apt/sources.list.d/vscode.list'
sudo apt update
sudo apt install code -y
    2. Установите плагин Python в VS Code для разработки программ.

    в заключение

    руководство по использованию пипа

    1. Что такое пип?

    2. Основные операции pip

    3. Расширенные функции

    4. Часто задаваемые вопросы и решения

    5. Лучшие практики для pip

    папка pip/cache/http-v2

    1. Что такое папка pip/cache/http-v2?

    2. Назначение папки http-v2

    3. Управление папками http-v2.

    4. Меры предосторожности

    Базовая структура данных Python

    Проверьте тип переменной

    Используйте тип()

    type()Функция может возвращать тип объекта.

    
x = 10
print(type(x))   # <class 'int'>

y = "hello"
print(type(y))   # <class 'str'>

    Используйте isinstance()

    isinstance()Используется для проверки принадлежности переменной к определенному типу и поддерживает проверку нескольких типов.

    
x = 10

print(isinstance(x, int))         # True
print(isinstance(x, str))         # False
print(isinstance(x, (int, float))) # True

    разница

    Логический тип данных Python

    Boolean в Python — это основной тип данных в программировании, который представляет два логических состояния: True или False. Это основа всех условных суждений и контроля процессов.

    1. Булевы значения и типы

    а = Истина
б = Ложь
print(type(a)) # Вывод: <class 'bool'>

    2. Связь между Боллинджером и цифрами

    Внутри Питона,boolцелое числоintподкатегории , чтобы они могли участвовать в числовых операциях:

    print(True + 1) # Вывод: 2 (1 + 1)
print(False * 5) # Вывод: 0 (0 * 5)

    3. Основное использование: оператор сравнения.

    Операторы сравнения сравнивают два значения и возвращают логический результат.

    оператор описывать пример результат
    == равный 10 == 10 True
    != не равен 5 != 10 True
    > больше, чем 10 > 5 True
    <= меньше или равно 5 <= 5 True

    4. Логические операторы

    Логические операторы используются для объединения или изменения логических значений или логических выражений.

    print(True и False) # Вывод: False
print(True или False) # Вывод: True
print(not True) # Вывод: False

    5. Проверка истинности

    В Python все объекты имеют истинностное значение. Когда объект используется для условного суждения, Python преобразует его вTrueилиFalse：

    if []: # Пустые списки считаются ложными
    print("Это не будет выполнено")
еще:
    print("Список пуст")

if "hello": # Непустые строки считаются True
    print("Строка не пуста")

    Массив Python

    Что такое массив?

    В Python массив — это структура данных, используемая для хранения нескольких элементов одного типа. Хотя сам Python не имеет встроенного типа массива, вы можете использоватьlistилиarrayМодули для достижения аналогичной функциональности.

    Использовать список как массив

    listЭто встроенная структура данных Python, которая может хранить многие типы данных, но также может использоваться для моделирования массивов.

    мой_список = [1, 2, 3, 4, 5]
print(my_list[0]) # Вывод: 1

    Использование модуля массива

    Если вам нужен настоящий массив (все элементы должны быть одного типа), вы можете использоватьarrayМоды.

    импортировать массив

my_array = array.array('i', [1, 2, 3, 4, 5])
print(my_array[0]) # Вывод: 1

    здесь,'i'Указывает, что элементы массива являются целыми числами.

    Основные операции модуля массива

    Вот некоторые основные операции:

    Массивы и NumPy

    В ситуациях, когда требуются числовые операции,numpyОбеспечивает более мощную поддержку массивов.

    импортировать numpy как np

my_numpy_array = np.array([1, 2, 3, 4, 5])
print(my_numpy_array[0]) # Вывод: 1

    Массивы NumPy поддерживают многомерные данные и векторизованные операции, что делает их идеальными для обработки больших объемов данных.

    в заключение

    Python предоставляет множество способов реализации функций массива.listПрименимо к общим ситуациям,arrayМодули подходят для ситуаций, когда требуются элементы одного и того же типа, тогда какnumpyЭто инструмент выбора для научных вычислений.

    Определить, пуст ли список

    для переменныхret_value = [], существует несколько простых и эффективных способов определить, является ли список пустым в языке Python. Поскольку пустой список рассматривается какFalseНиже приведены несколько часто используемых методов суждения.

    1. Используйте логическую оценку (наиболее рекомендуемый Pythonic-способ).

    Это самый популярный метод, предполагающий непосредственную проверку логического значения списка. Если список пуст,notоператор приведёт к тому, что его условие будет оценено как true (True）。

    ret_value = []

если не ret_value:
    #Выполнить здесь, когда список пуст
    print("ret_value — пустой список")
еще:
    #Выполнить здесь, если список не пуст
    print("ret_value не пустой список")

    2. Используйтеlen()функция

    Проверяет, равна ли длина списка 0.

    ret_value = []

если len(ret_value) == 0:
    print("ret_value — пустой список")
еще:
    print("ret_value не пустой список")

    3. Используйте эквивалентные сравнения== []

    Непосредственно назначьте переменные пустому литералу списка[]Сделайте сравнение.

    ret_value = []

если ret_value == []:
    print("ret_value — пустой список")
еще:
    print("ret_value не пустой список")

    Динамическое увеличение и уменьшение массива

    Использование списков для динамических операций

    В Python,listЭто динамическая структура данных, в которую можно легко добавлять и удалять элементы.

    Добавить новый элемент

    Новые элементы можно добавлять следующими способами:

    # Пример нового элемента
мой_список = [1, 2, 3]
my_list.append(4) # [1, 2, 3, 4]
my_list.insert(1, 10) # [1, 10, 2, 3, 4]
my_list.extend([5, 6]) # [1, 10, 2, 3, 4, 5, 6]

    Удалить элемент

    Удалить элементы можно с помощью:

    # Пример удаления элемента
мой_список = [1, 2, 3, 4, 5]
my_list.pop() # [1, 2, 3, 4]
my_list.remove(2) # [1, 3, 4]
my_list.clear() # []

    Динамические операции с использованием модуля массива

    В случаях, когда вам нужны элементы одного типа, вы можете использоватьarrayМоды.

    Добавить новый элемент

    append()иextend()Метод применяется кarrayМоды.

    import array
my_array = array.array('i', [1, 2, 3])
my_array.append(4)  # [1, 2, 3, 4]
my_array.extend([5, 6])  # [1, 2, 3, 4, 5, 6]

    Удалить элемент

    remove()иpop()Можно использовать методыarrayМоды.

    # Пример удаления элемента
my_array = array.array('i', [1, 2, 3, 4])
my_array.remove(2) # [1, 3, 4]
my_array.pop() # [1, 3]

    в заключение

    Python предоставляет множество методов для динамического увеличения и уменьшения массивов.listиarrayМодули подходят для разных нужд. Для получения дополнительных функциональных требований вы также можете рассмотреть возможность использованияnumpy。

    Подсчет массивов Python

    В Python,list.count()Это инструмент, специально используемый для статистики.Количество вхождений определенного элементаметод. Это то же самое, что получить длину спискаlen()В отличие от этого, параметр должен быть передан в качестве объекта сравнения.

    1. Основной синтаксис list.count()

    Синтаксис:list.count(value), который возвращает целое число раз, когда значение появляется в списке. Если значение не существует, возвращается 0.

    фрукты = ['яблоко', 'банан', 'яблоко', 'апельсин', 'яблоко']

# Подсчитаем количество вхождений слова «яблоко»
apple_count =fruits.count('яблоко')
print(apple_count) # Вывод: 3

# Подсчитаем несуществующие элементы
Grape_count = Fruits.count('виноград')
print(grape_count) # Вывод: 0

    2. Сравнение общих требований и инструментов подсчета

    В зависимости от ваших потребностей (ищете ли вы один элемент, несколько элементов или всю статистику), существуют различные рекомендации:

    нуждаться Рекомендуемый метод Пример кода
    Посчитайте один конкретный элемент list.count() arr.count(10)
    Получить общую длину списка len() len(arr)
    Подсчитайте частоту всех элементов collections.Counter Counter(arr)
    Количество условий (если больше 5) выражение генератора sum(1 for x in arr if x > 5)

    3. Расширенные инструменты: коллекции.Счетчик.

    Если вам нужно узнать, сколько раз «все элементы» появляются в списке одновременно, используйтеCounterБудет запускаться много разcount()Гораздо более эффективно (O(n) против O(n^2)).

    из коллекций Счетчик импорта

данные = [1, 2, 2, 3, 3, 3, 4]
counts = Счетчик(данные)

print(counts) # Вывод: Counter({3: 3, 2: 2, 1: 1, 4: 1})
print(counts[3]) # Получаем количество раз 3:3
print(counts.most_common(1)) # Получаем элемент с наибольшим количеством вхождений

    4. Напоминания об использовании легко сбивают с толку.

    5. Практические навыки: условный счет.

    Если вы хотите подсчитать количество элементов, соответствующих определенной логике (например, строки длиной более 3), вы можете объединитьsum()：

    слова = ['привет', 'привет', 'питон', 'а', 'код']

# Подсчитаем количество слов длиной > 3
big_word_count = sum(1 для w в словах, если len(w) > 3)
print(big_word_count) # Вывод: 3

    Объединение 2D-списков

    Описание требований

    Пример программы

    список1 = [
    ["а", 1],
    ["б", 2],
    ["с", 3]
]

список2 = [
    ["с", 30],
    ["а", 10],
    ["д", 40]
]

#Преобразовать список1 в dict
dict1 = {k: v для k, v в списке1}
dict2 = {k: v для k, v в списке2}

# Найти все ключи
all_keys = sorted(set(dict1.keys()) | set(dict2.keys()))

# Объединить результаты
объединен = []
для k во всех_клавишах:
    v1 = dict1.get(к)
    v2 = dict2.get(к)
    merged.append([k, v1, v2])

для строки в слиянии:
    печать (строка)

    Вывод результатов

    
['a', 1, 10]
['b', 2, None]
['c', 3, 30]
['d', None, 40]

    в заключение

    Зацикливание двух списков одновременно

    В Python, если у вас есть два списка (например,selected_fields_listиaSqlValuesStr_list), и необходимо перебирать их одновременно, наиболее распространенным и Pythonic способом является использование встроенного методаzip()функция.

    1. Используйте функцию zip().

    zip()Функция упаковывает несколько итерируемых объектов (Iterable) в последовательность кортежей. Каждая итерация цикла удаляет элемент в соответствующей позиции из каждого списка.

    импортировать повторно

# Предположим, что это два списка, которые вы получаете после re.split()
selected_fields = "имя,возраст,город"
aSqlValuesStr = "Алиса, 25, Тайбэй"

selected_fields_list = re.split(r',', selected_fields)
aSqlValuesStr_list = re.split(r',', aSqlValuesStr)

# Выполнить цикл
для поля значение в zip(selected_fields_list, aSqlValuesStr_list):
    print(f"Поле: {поле}, значение: {значение}")

    2. Пример вывода

    Поле: имя, значение: Алиса
Поле: возраст, значение: 25
Поле: город, значение: Тайбэй

    3. Важные замечания по zip()

    Когда вы используетеzip()При использовании функций необходимо обратить внимание на следующие моменты:

    #Пример: несовместимая длина списков
список1 = [1, 2, 3]
список2 = ['а', 'б']

для элемента1, элемента2 в zip(список1, список2):
    печать(элемент1, элемент2)
#Вывод будет только:
# 1а
#2б

    Выровнять отображение 2D-массива

    Выровнять поля по формату

    данные = [
    [1, 23, 456],
    [7890, 12, 3],
    [45, 678, 9]
]

# Вычисляем максимальную ширину каждого столбца
col_widths = [max(len(str(row[i])) для строки в данных) для i в диапазоне(len(data[0]))]

# Форматируем вывод
для строки в данных:
    print(" ".join(str(val).rjust(col_widths[i]) for i, val в enumerate(row)))

    Вывод результатов

    
   1   23  456
7890   12    3
  45  678    9

    Использование модуля таблицы

    Сторонние пакетыtabulateВыровненные таблицы можно вывести напрямую.

    
from tabulate import tabulate

data = [
    [1, 23, 456],
    [7890, 12, 3],
    [45, 678, 9]
]

print(tabulate(data, tablefmt="grid"))

    Вывод результатов

    
+------+-----+-----+
|    1 |  23 | 456 |
| 7890 |  12 |   3 |
|   45 | 678 |   9 |
+------+-----+-----+

    в заключение

    Выровненный вывод двумерных чисел с плавающей запятой

    иллюстрировать

    В следующем примере показано, как распечатать двумерный список. Когда элементfloatИсправлено отображение двух знаков после запятой, остальные элементы выводятся как есть, с сохранением выравнивания полей.

    Пример программы

    данные = [
    [1, 23.456, 456],
    [7890.1, 12, 3.5],
    [45, 678,9, 9]
]

# Форматируем каждую строку элемента
форматированные_данные = []
для строки в данных:
    новая_строка = []
    для значения в строке:
        если isinstance(val, float):
            s = f"{val:.2f}" # float -> два знака после запятой
        еще:
            s = ул (значение)
        new_row.append(ы)
    formatted_data.append(новая_строка)

# Вычисляем максимальную ширину каждого столбца
col_widths = [max(len(row[i]) для строки в formatted_data) для i в диапазоне(len(formatted_data[0]))]

# Форматируем вывод
для строки в formatted_data:
    print(" ".join(val.rjust(col_widths[i]) for i, val in enumerate(row)))

    Вывод результатов

    
    1  23.46  456
7890.10     12  3.50
   45  678.90     9

    сосредоточиться

    Извлечь все значения из списка словаря

    Предоставляемая вами структура данных представляет собой список, содержащий несколько словарей, где каждый словарь представляет запись временного ряда (например, данные K-линии).

    data = [
    {'time': 1759028400000, 'open': '109398.3', 'close': '109364.8', 'high': '109489.2', 'low': '109364.8', 'volume': '518.7594'},
    {'time': 1759024800000, 'open': '109305.6', 'close': '109398.3', 'high': '109496.4', 'low': '109296.0', 'volume': '757.0290'},
    # ...
]

    Если вы хотите получить все значения во всех записях (1759028400000, '109398.3', '109364.8'и т. д.) и собрать их в список, вы можете использовать Nested List Comprehension.

    1. Извлечь все значения в единый список (сведение)

    Используйте двухуровневое понимание списка для перебора каждого словаря в списке, а затем вызовите.values()Метод получает значения и, наконец, собирает все значения в плоский список.

    данные = [
    {'время': 1759028400000, 'открытие': '109398.3', 'закрытие': '109364.8', 'высокая': '109489.2', 'низкая': '109364.8', 'объем': '518.7594'},
    {'время': 1759024800000, 'открытие': '109305.6', 'закрытие': '109398.3', 'высокая': '109496.4', 'низкая': '109296.0', 'объем': '757.0290'}
]

все_значения = [
    ценность
    для записи в данных # Пройти каждую запись словаря во внешнем списке
    for value in Record.values() # Обход всех значений в записи словаря
]

печать (все_значения)

    2. Вывод результатов

    В результате получается единый список, содержащий все значения:

    [1759028400000, '109398.3', '109364.8', '109489.2', '109364.8', '518.7594', 1759024800000, '109305.6', '109398.3', '109496.4', '109296.0', '757.0290']

    3. Извлеките значение определенного поля.

    Если вам нужно извлечь только определенные поля (например, только всеopenцена), вы можете использовать одноуровневое понимание списка:

    data = [
    {'time': 1759028400000, 'open': '109398.3', ...},
    {'time': 1759024800000, 'open': '109305.6', ...}
]

open_prices = [record['open'] for record in data]

print(open_prices)

    Результат вывода:

    ['109398.3', '109305.6']

    Извлечь значение определенного ключа из списка словаря

    1. Используйте понимание списка (рекомендуется) ✅

    Понимание списков — это краткий однострочный синтаксис для создания новых списков из существующих списков.

    Примеры реализации Python

    из даты и времени импорта даты и времени

список_данных = [
    {'videoid': 'b5HxsaM_E2Y', 'publishedat': datetime(2025, 12, 7, 3, 0, 53), 'rankno': 7, 'viewcount': 913053, 'query': 'бейсбол'},
    {'videoid': 'FEbMCBxsoWI', 'publishedat': datetime(2025, 11, 25, 5, 28, 6), 'rankno': 13, 'viewcount': 754598, 'query': 'бейсбол'},
    {'videoid': 'nOJUI0PGB68', 'publishedat': datetime (2025, 12, 7, 3, 7, 46), 'rankno': 14, 'viewcount': 748349, 'query': 'бейсбол'},
    {'videoid': 'uMHXIudw_w0', 'publishedat': datetime (2025, 12, 2, 10, 1, 38), 'rankno': 8, 'viewcount': 687949, 'query': 'бейсбол'}
]

target_key = 'идентификатор видео'

# Используйте понимание списка: для каждого элемента словаря в data_list извлеките элемент [target_key]
video_ids = [item[target_key] для элемента в data_list]

print(f"Извлеченный ключ: {target_key}")
print("Все значения videoid:")
печать (video_ids)

    Вывод результатов

    ['b5HxsaM_E2Y', 'FEbMCBxsoWI', 'nOJUI0PGB68', 'uMHXIudw_w0']

    2. Обработка ситуации, когда ключ может не существовать (безопасный доступ).

    Если в некоторых словарях в списке может отсутствовать целевой ключ (например, в некоторых словарях нет ключа `videoid`), использование `item[target_key]` напрямую приведет к ошибке `KeyError`. Вы можете использовать метод `.get()` словаря или условное выражение для его безопасной обработки.

    Пример реализации Python (безопасный доступ)

    data_with_missing_key = [
    {'videoid': 'A1', 'query': 'футбол'},
    {'query': 'basketball'}, # Отсутствует ключ 'videoid'
    {'videoid': 'C3', 'query': 'Волейбол'}
]

target_key = 'идентификатор видео'

# Вариант A: используйте .get(), чтобы установить значение по умолчанию None (или любое другое значение)
Safe_video_ids_A = [item.get(target_key) для элемента в data_with_missing_key]
# Вывод: ['A1', Нет, 'C3']

# Вариант Б: извлечь только значения с этим ключом
Safe_video_ids_B = [item[target_key] для элемента в data_with_missing_key, если target_key в элементе]
# Вывод: ['A1', 'C3']

print(f"\nРезультаты безопасного извлечения (План Б): {safe_video_ids_B}")

    Преобразование значений dict в список

    вы изonesymbollist.values()Полученный результат представляет собой объект представления словаря Python.dict_values. Хотя он выглядит как список, это динамическое представление, а не стандартный список, который можно индексировать или изменять.

    dict_values([1763510400000, '0.00015218', '0.00015336', '0.00015415', '0.00015067', '1634523'])

    Не показыватьdict_values()Чтобы получить содержимое тега, самый простой и распространенный способ — использовать встроенный методlist()Функция приводит его к списку.

    1. Преобразовать в список (список)

    Воляdict_valuesперешел кlist()Функция, которая немедленно скопирует все элементы объекта представления в новый стандартный список.

    # Предположим, что это полученный вами объект представления dict_values
dict_values_object = your_dictionary.values() # Предположим, что onesymbollist — это словарь

# Шаг: используйте функцию list() для преобразования
result_list = список (dict_values_object)

печать (список_результатов)

    Вывод результатов

    [1763510400000, '0.00015218', '0.00015336', '0.00015415', '0.00015067', '1634523']

    2. Преобразовать в кортеж

    Если ваша цель — создать неизменяемую последовательность, вы можете использоватьtuple()Функция преобразует его в кортеж.

    result_tuple = tuple(dict_values_object)

print(result_tuple)

    Вывод результатов

    (1763510400000, '0.00015218', '0.00015336', '0.00015415', '0.00015067', '1634523')

    3. Прямая итерация (преобразование не требуется)

    Обратите внимание: если вы просто хотите обрабатывать значения по одному в цикле, вам не нужно явно преобразовывать их в список.dict_valuesСам по себе является итерируемым объектом (Iterable).

    # Предположим, что это полученный вами объект представления dict_values
dict_values_object = your_dictionary.values()

print("Выводные элементы один за другим:")
для значения в dict_values_object:
    печать (значение)

    Короче говоря, используйтеlist(your_dict.values())— это наиболее распространенный способ получить чистый и действенный список значений.

    Преобразование значений словаря в строку, разделенную запятыми

    начать сdict_valuesИзвлекает все значения из объекта представления и объединяет их в одну строку, разделенную только запятыми и пробелами (например:1763510400000, '0.00015218', ...), вам необходимо объединить следующие шаги:

    1. взять из словаряdict_valuesПосмотреть объект.
    2. Преобразует все элементы в этом объекте представления в строковые типы.
    3. Использование Python", ".join()метод для объединения этих строк.

    1. Реализация Python

    Предположим, ваш исходный словарь называетсяonesymbol_dict, и вам необходимо преобразовать нестроковые значения (например, метки времени) в строки для использования.join()Установите связь.

    onesymbol_dict = {
    «время»: 1763510400000,
    «открыть»: «0,00015218»,
    'закрыть': '0,00015336',
    «высокий»: «0,00015415»,
    «низкий»: «0,00015067»,
    'объем': '1634523'
}

# Шаг 1 и усиление; 2. Получите значения и преобразуйте все значения в строки.
# Используйте понимание списков, чтобы гарантировать, что все элементы являются строками
values_as_strings = [str(v) для v в onesymbol_dict.values()]

# Шаг 3: Используйте ', '.join() для объединения этих строк
values_string = ", ".join(values_as_strings)

печать (строка_значений)

    2. Вывод результатов

    Это создаст одну строку, содержимым которой является только значение без каких-либо внешних скобок илиdict_valuesЭтикетка:

    1763510400000, 0.00015218, 0.00015336, 0.00015415, 0.00015067, 1634523

    3. Примечания к строковым кавычкам

    Обратите внимание, что в ожидаемом выводе примера значения, отличные от меток времени, заключены в одинарные кавычки:1763510400000, '0.00015218', ...。

    Если ваша цель — чтобы строковые значения сохраняли одинарные кавычки в конечном выводе, вам нужно будет добавлять кавычки вручную во время конкатенации. Обычно это требуется при подготовке строк для операторов SQL или определенных форматов.

    # Дополнительный шаг: обработка котировок вручную, предполагая, что нецелые значения требуют кавычек
Quote_values = []
для v в onesymbol_dict.values():
    если isinstance(v, (str, float)) или (isinstance(v, int) и v< 1000000000000): # 假設小數字串需要引號
        quoted_values.append(f"'{v}'")
    else:
        quoted_values.append(str(v))

final_quoted_string = ", ".join(quoted_values)

print(final_quoted_string)

    Это даст вам ожидаемый формат (при условии, чтоtimeКавычки не требуются, можно использовать другие числовые строки):

    1763510400000, '0.00015218', '0.00015336', '0.00015415', '0.00015067', '1634523'

    Определить, является ли строка числом

    Используйте str.isdigit()

    isdigit()Метод можно использовать для проверки того, содержит ли строка только числовые символы.

    # Пример
строка = "12345"
если строка.isdigit():
    print("это число")
еще:
    print("Не число")

    Уведомление:isdigit()Невозможно обрабатывать десятичные точки или отрицательные знаки.

    Используйте str.replace() для обработки десятичных знаков.

    Если вам нужно проверить строку с десятичной точкой, вы можете удалить десятичную точку перед использованиемisdigit()。

    # Пример
строка = "123,45"
если string.replace(".", "").isdigit():
    print("это число")
еще:
    print("Не число")

    Этот метод не работает с отрицательными числами.

    Преобразование в число с помощью try-кроме

    Самый распространенный подход — попытаться преобразовать строку в число с плавающей запятой или целое число и перехватить исключение, если преобразование завершится неудачно.

    # Пример
строка = "-123,45"
попробуйте:
    float(string) # Вместо этого вы можете использовать int(string) для проверки целых чисел
    print("это число")
кроме ValueError:
    print("Не число")

    Используйте регулярные выражения

    Регулярные выражения могут точно соответствовать числам, включая целые, десятичные и отрицательные числа.

    # Пример
импортировать повторно

строка = "-123,45"
шаблон = r"^-?\d+(\.\d+)?$"
если re.match(шаблон, строка):
    print("это число")
еще:
    print("Не число")

    в заключение

    В простых случаях используйтеisdigit(). В более сложных случаях (например, работа с десятичными или отрицательными числами) рекомендуется использоватьtry-exceptили регулярное выражение.

    Python f-string

    f-строка (форматированный строковый литерал) — это мощный и эффективный метод форматирования строк, представленный в Python 3.6. Он обеспечивает краткий и легко читаемый способ встраивания значений переменных и выражений в строки.

    Основная особенность f-строки: использование префиксов в начале строки.fилиFи используйте фигурные скобки{}содержать то, что должно быть рассчитано и отображено.

    1. Основное использование: встраивание переменных.

    Вы можете поместить любое имя переменной непосредственно в фигурные скобки.

    имя = "Алиса"
возраст=30
message = f"Здравствуйте, меня зовут {name}, мне {age} лет."
# Вывод: Здравствуйте, меня зовут Алиса, мне 30 лет.

    2. Встроенные выражения

    Преимущество f-строки в том, что вы можете поместить любое допустимое выражение Python в фигурные скобки, и оно будет оценено во время выполнения.

    цена = 19,99
налог_ставка = 0,05
итого = цена * (1 + ставка_налога)

# Выполняем вычисления внутри f-строки
result = f"Общая цена, включая налог, составляет: {price * (1 + Tax_rate):.2f} юаней."
# Вывод: общая цена, включая налог, составляет 20,99 юаней.

# Функция вызова
защита get_status():
    вернуть «ОК»

status_msg = f"Состояние системы: {get_status()}"
# Вывод: Статус системы: ОК

    3. Форматирование и выравнивание строк.

    поддерживает фа-струны и.format()Тот же метод, что и в мини-языке спецификатора формата, с использованием двоеточия.:для разделения выражений и спецификаторов формата.

    код формата использовать пример выход
    :.2f Число с плавающей запятой с двумя десятичными знаками f"{3.14159:.2f}" 3.14
    : <10 Выровнять по левому краю, ширина 10 f"{'Name':<10}" Name
    : >10 Выровнять по правому краю, ширина 10 f"{'Value':>10}" Value
    :^10 Выравнивание по центру, ширина 10 f"{'Hi':^10}" Hi
    :, Числовой разделитель тысяч f"{1000000:,}" 1,000,000

    4. Отладка F-строк

    Начиная с Python 3.8, f-строка предоставляет удобную функцию отладки, которая позволяет добавлять знак равенства после переменной.=, автоматически отображает имена переменных и их значения.

    user_id = 42
is_active = Истина

debug_output = f"Идентификатор пользователя: {user_id=}, статус: {is_active=}"
# Вывод: идентификатор пользователя user_id=42, статус: is_active=True

    5. Меры предосторожности

    f-строка не отображает десятичные точки с плавающей запятой

    1. Решение 1. Преобразование целых чисел внутри f-строки (рекомендуется)

    Подтяжки на стрингах{}Внутри вы можете напрямую использоватьint()Функция преобразует переменную обратно в целочисленный тип. Это самый ясный и прямой метод.

    Примеры реализации Python

    inta = 12 # при условии необработанного целого числа
float_a = inta * 2.0 # Результат — 24,0 (число с плавающей запятой)

# Преобразование числа с плавающей запятой обратно в целое число непосредственно в f-строке
result_str = f"abc def {int(float_a)}"

print(f"Исходное значение (float_a): {float_a}")
print(f"Отформатированный результат: {result_str}")

    2. Вариант 2. Используйте спецификатор формата f-строки (описатель формата).

    Вы можете использовать коды целочисленного формата из мини-языка форматирования.dили.0fдля управления выходным форматом.

    A. Используйте коды целочисленного формата:d

    использовать:dPython просят рассматривать значение как целое число при отображении. если переменнаяa— это число с плавающей запятой, Python автоматически округлит его до ближайшего целого числа перед отображением (если результат вашего расчета равен $24,0$, он отобразит $24$).

    float_a = 24,0
result_d = f"abc def {float_a:d}"
# Вывод: abc def 24

    Б. Используйте код формата с плавающей запятой:.0f

    использовать:.0fозначает форматирование значения как числа с плавающей запятой, но требует 0 цифр после десятичной точки. Это также приведет к округлению результатов перед отображением.

    float_a = 24,0
result_0f = f"abc def {float_a:.0f}"
# Вывод: abc def 24

    Резюме и предложения

    Если ваша цель — обеспечить, чтобы результат был абсолютным целым числом без десятичной точки, рекомендуется использовать вариант 1:

    str = f"abc def {int(a)}"

    Функция повторного разделения Python

    В Python,re.split()ФункцияreМощный инструмент в модуле (регулярное выражение), используемый для разделения строк в соответствии с разделителями (шаблонами), определенными в регулярных выражениях, и возврата результатов в виде списка (списка).

    1. Синтаксис функции

    re.split(pattern, string, maxsplit=0, flags=0)

    2. Основное использование

    Используйте регулярные выражения для определения нескольких или сложных разделителей.

    импортировать повторно

text = "яблоко,банан;апельсин-виноград"
# Используйте запятую, точку с запятой или дефис в качестве разделителя
результат = re.split(r'[;,-]', текст)

печать (результат)
# Вывод: ['яблоко', 'банан', 'апельсин', 'виноград']

    3. Обработка нескольких пробелов (обычное использование)

    со стандартными струнамиsplit()другой,re.split()Несколько последовательных разделителей (например, несколько пробелов) можно легко обработать и игнорировать.

    текст = "Слово1 Слово2 Слово3"
# Используйте \s+ для соответствия одному или нескольким символам пробелов в качестве разделителей
результат = re.split(r'\s+', текст)

печать (результат)
# Вывод: ['Слово1', 'Слово2', 'Слово3']

    4. Используйте maxsplit, чтобы ограничить количество разрезов.

    Если установленоmaxsplit, операция вырезания будет выполнена только указанное количество раз, а остальные детали останутся в списке последним элементом.

    текст = "один:два:три:четыре"
# Разрезать только один раз
результат = re.split(r':', text, maxsplit=1)

печать (результат)
# Вывод: ['один', 'два:три:четыре']

    5. Сохраняйте разделители

    Если вы поместите шаблон-разделитель внутри скобок(), сам разделитель также будет включен между элементами списка результатов.

    текст = "15 января 2025 г."
# Поместите дефисы в круглые скобки, чтобы они сохранились
результат = re.split(r'(-)', текст)

печать (результат)
# Вывод: ['2025', '-', '01', '-', '15']

    Определить начало строки начинается с

    использовать

    startswith()это строка Python (str) метод объекта, используемый для определения того, начинается ли строка с указанной подстроки. Если оно соответствует, вернитеTrue; В противном случае вернитеFalse。

    грамматика

    
str.startswith(prefix[, start[, end]])

    Описание параметра

    возвращаемое значение

    Логическое значение: если строка начинается с указанного префикса, вернитеTrue,в противном случаеFalse。

    пример

    text = "Программирование на Python"

#Основное использование
print(text.startswith("Py")) # True
print(text.startswith("Java")) # False

#Указать диапазон
print(text.startswith("thon", 2)) # True (начиная с индекса 2 — "thon")

# несколько выравниваний
print(text.startswith(("Py", "Java", "C"))) # Верно, потому что любое совпадение

# Не чувствителен к регистру (можно сначала преобразовать в нижний регистр)
print(text.lower().startswith("py")) # True

    Общие приложения

    продлевать

    Чтобы определить, «заканчивается» ли строка определенным текстом, вы можете использоватьendswith()методы, синтаксис иstartswith()такой же.

    имя файла = "отчет.pdf"
если имя_файла.endswith(".pdf"):
    print("Это PDF-файл")

    Удалить последний символ строки

    иллюстрировать

    В Python строки являются неизменяемыми объектами. Чтобы удалить последний символ, обычно используется разрезание строки для создания новой строки.

    пример

    текст = "Привет!"

#Метод 1: используйте нарезку
новый_текст = текст[:-1]
print(new_text) #Вывод: Здравствуйте

#Метод 2: используйте rstrip() для удаления определенных конечных символов
text2 = "Привет!!!"
новый_текст2 = text2.rstrip("!")
print(new_text2) #Вывод: Здравствуйте

#Метод 3: убедитесь, что он не пуст, а затем удалите последний символ.
если текст:
    текст = текст[:-1]
печать (текст)

    Вывод результатов

    
Hello
Hello
Hello

    иллюстрировать

    продлевать

    Чтобы удалить ведущие символы, используйте:

    
text = text[1:]

    Подвести итог

    Найдите содержимое перед подстрокой в ​​строке

    Постановка задачи

    Учитывая строкуstr1, мы надеемся найти вstrAилиstrBТа часть, которая предшествует. Например:

    str1 = "Hello World, this is a test. Stop here or continue."
strA = "Stop"
strB = "continue"

    Цель состоит в том, чтобы получить"Hello World, this is a test. "。

    Используйте re.split()

    re.split()Вы можете разделить строку на основе нескольких ключевых слов и взять первую часть:

    import re

def get_substring_before(text, strA, strB):
    result = re.split(f"{re.escape(strA)}|{re.escape(strB)}", text, maxsplit=1)[0]
    return result

str1 = "Hello World, this is a test. Stop here or continue."
strA = "Stop"
strB = "continue"

print(get_substring_before(str1, strA, strB))  # "Hello World, this is a test. "

    Используйте исследование.search()

    re.search()можно использовать для сопоставленияstrAилиstrBи получите содержимое перед сопоставлением:

    import re

def get_substring_before(text, strA, strB):
    match = re.search(f"{re.escape(strA)}|{re.escape(strB)}", text)
    return text[:match.start()] if match else text

str1 = "Hello World, this is a test. Stop here or continue."
print(get_substring_before(str1, "Stop", "continue"))  # "Hello World, this is a test. "

    Используйте метод find()

    find()Вы можете вручную выполнить поиск самого раннегоstrAилиstrB, а затем извлеките соответствующую часть:

    def get_substring_before(text, strA, strB):
    indexA = text.find(strA)
    indexB = text.find(strB)
    
    indices = [i for i in [indexA, indexB] if i != -1]
    first_index = min(indices, default=len(text))
    
    return text[:first_index]

str1 = "Hello World, this is a test. Stop here or continue."
print(get_substring_before(str1, "Stop", "continue"))  # "Hello World, this is a test. "

    в заключение

    Объединение нескольких значений в строку

    Используйте соединение (сначала вам нужно преобразовать все в строки)

    значения = ["str1", "str2", 123, "str3", 456]

s = ", ".join(str(v) для v в значениях)
print(s) # Вывод: str1, str2, 123, str3, 456

    Автоматически обрабатывать смешанные строки и целые числа

    def join_values(*args, sep=", "):
    return sep.join(str(v) для v в args)

print(join_values("str1", "str2", 88, "str3"))
# Вывод: строка1, строка2, 88, строка3

    Если источником является dict, отсортируйте по ключу, а затем объедините

    данные = {
    "str1": "привет",
    "str2": "мир",
    "int1": 123,
    "str3": "ок"
}

# Сортируем по ключу и затем присоединяемся
s = ", ".join(str(data[k]) for k in sorted(data.keys()))
print(s) # привет, мир, 123, ок

    Чтобы соединить ключ + значение вместе

    s = ", ".join(f"{k}={v}" для k, v в data.items())
печать(и)
# Вывод: str1=привет, str2=мир, int1=123, str3=ok

    Источником является список диктовок, каждый диктовок объединен в один столбец.

    rows = [
    {"str1": "A", "int1": 10},
    {"str1": "B", "int1": 20},
]

for row in rows:
    print(", ".join(str(v) for v in row.values()))
# A, 10
# B, 20

    Универсальная функция: переключение между режимами «с кавычками» и «без кавычек».

    def join_values(values, sep=", ", quote=False):
    если цитировать:
        # Используйте полные одинарные кавычки ''
        return sep.join(f"'{v}'" для v в значениях)
    еще:
        return sep.join(str(v) для v в значениях)

значения = ["str1", "str2", 88, "str3"]

print(join_values(значения, кавычки=False))
# Вывод: строка1, строка2, 88, строка3

print(join_values(значения, кавычки=True))
# Вывод: «str1», «str2», «88», «str3»

    Может поддерживать версию ввода *args

    def join_args(*args, sep=", ", quoted=False):
    if quoted:
        return sep.join(f"‘{v}’" for v in args)
    return sep.join(str(v) for v in args)

print(join_args("str1", "str2", 88, "str3", quoted=True))
# ‘str1’, ‘str2’, ‘88’, ‘str3’

    Поддержка dict (только выходное значение)

    data = {"str1": "hello", "str2": "world", "int1": 123}

print(join_values(data.values(), quoted=True))
# ‘hello’, ‘world’, ‘123’

    Поддержка формата ключ=значение

    def join_key_value(d, sep=", ", quoted=False):
    if quoted:
        return sep.join(f"{k}=‘{v}’" for k, v in d.items())
    return sep.join(f"{k}={v}" for k, v in d.items())

print(join_key_value(data, quoted=True))
# str1=‘hello’, str2=‘world’, int1=‘123’

    re.match()

    re.match()

    Питонre.matchФункция в модуле регулярных выражений, используемая для сопоставления с начала строки. Если совпадение прошло успешно, вернитеMatchобъект; в противном случае возвратNone。

    грамматика

    re.match(pattern, string, flags=0)

    Описание параметра:

    Общие свойства и методы

    Примеры использования

    импортировать повторно

#Определяем строку
text = "123 Привет, мир!"

# Используйте re.match для сопоставления чисел с начала
match = re.match(r"(\d+)\s+(.*)", text)

если совпадение:
    print(f"Весь результат сопоставления: {match.group(0)}") # 123 Hello World!
    print(f"Часть числа: {match.group(1)}") # 123
    print(f"Текстовая часть: {match.group(2)}") # Привет, мир!
еще:
    print("совпадение не удалось")

    Вывод результатов

    Полный результат сопоставления: 123 Hello World!
Числовая часть: 123
Текстовая часть: Привет, мир!

    На что следует обратить внимание

    регулярное выражение

    Регулярное выражение (сокращенно Regex) — это синтаксис, используемый для описания правил сопоставления строк. Он часто используется для поиска, замены или проверки строк. на PythonreВ модулеpatternЭто основная часть определения этих правил.

    основные элементы синтаксиса

    Расширенное использование

    пример

    импортировать повторно

# Пример 1: Сопоставление содержимого, начинающегося с цифры
шаблон = r"^\d+"
текст = "123abc"
match = re.match(шаблон, текст)
если совпадение:
    print(f"Результат сопоставления: {match.group()}") # Вывод: 123

#Пример 2: Сопоставление текста после чисел
шаблон = r"(\d+)\s+(.*)"
text = "123 Привет, мир"
match = re.match(шаблон, текст)
если совпадение:
    print(f"Часть числа: {match.group(1)}") # Вывод: 123
    print(f"Текстовая часть: {match.group(2)}") # Вывод: Hello World

    Сценарии применения регулярных выражений

    Применение исследования()

    Основное использование

    re.search()Используется для поиска первого совпадения регулярного выражения в строке и его возврата.MatchОбъект, возвращаемый, если совпадений нетNone。

    импортировать повторно

text = «Привет, 2024!»
match = re.search(r"\d+", текст)

если совпадение:
    print("Найден номер:", match.group()) # 2024

    Объект обратного совпадения

    когдаre.search()Когда совпадение найдено, оно возвращаетMatchОбъекты могут получать доступ к информации следующими способами:

    импортировать повторно

text = "Python 3.10 великолепен!"
match = re.search(r"\d+\.\d+", text)

если совпадение:
    print("Сопоставить содержимое:", match.group()) # 3.10
    print("Начальный индекс:", match.start()) # 7
    print("Конечный индекс:", match.end()) # 11
    print("диапазон:", match.span()) # (7, 11)

    Используйте групповое сопоставление

    через скобки()создать группу и использоватьgroup(n)для извлечения соответствующего соответствующего контента.

    импортировать повторно

text = "Джон Доу, Возраст: 25"
match = re.search(r"(\w+) (\w+), Возраст: (\d+)", text)

если совпадение:
    print("Фамилия:", match.group(1)) # Джон
    print("name:", match.group(2)) # Доу
    print("Возраст:", match.group(3)) # 25

    Сравнение с re.findall()

    re.search()Возвращается только первый соответствующий результат, тогда какre.findall()Все совпадающие результаты будут возвращены.

    import re

text = "Price: $10, Discount: $2, Tax: $1"

match = re.search(r"\$\d+", text)
print("re.search:", match.group())  # $10

matches = re.findall(r"\$\d+", text)
print("re.findall:", matches)  # ['$10', '$2', '$1']

    в заключение

    re.search()Подходит для поиска первого результата сопоставления и может использоваться дляMatchОбъект для получения подробной информации. Для нескольких совпадающих результатов используйтеre.findall()。

    Незахватывающие группы регулярных выражений

    Улучшите производительность сопоставления

    В регулярном выражении(...)Соответствующий контент будет записан и сохранен вgroup(n), но не группа захвата(?:...)Он используется только для организационной структуры и не влияет на номер группы, поэтому сопоставление происходит быстрее.

    Не влияйте на групповой индекс

    Если используется в регулярном выражении()организовать условия сопоставления, которые повлияютgroup(n)число. использовать(?:...)Это гарантирует, что индекс группы останется неизменным.

    import re

text = "2024-03-12"
pattern = r"(\d{4})-(?:\d{2})-(\d{2})"

match = re.search(pattern, text)
print(match.group(1))  # 2024
print(match.group(2))  # 12

    В сочетании с оператором OR

    использовать(?:...|...)могу позволить|Оператор влияет на сопоставление содержимого, но не на групповой доступ.

    import re

text = "bar123"
pattern = r"(?:foo|bar|baz)\d+"

match = re.search(pattern, text)
print(match.group())  # bar123

    Применяется к анализу --user-data-dir

    При анализе параметров Chrome используйте(?:...)Это гарантирует, что формат соответствия не повлияет на номер группы.

    import re

cmdline = '--user-data-dir="C:\\Users\\moirg\\AppData\\Local\\Google\\Chrome\\User Data"'

match = re.search(r'--user-data-dir=(?:"([^"]+)"|(\S+))', cmdline)
user_data_dir = match.group(1) or match.group(2)

print(user_data_dir)  # C:\Users\moirg\AppData\Local\Google\Chrome\User Data

    в заключение

    (?:...)Он может повысить производительность регулярных выражений, избежать влияния на индекс группы и подходит для|Операции и сопоставление конкретных условий делают код более эффективным и понятным.

    Дата и время Python

    Модуль импорта

    import datetime

    Получить текущее время

    now = datetime.datetime.now()
print(now)

    Создать указанное время

    dt = datetime.datetime(2025, 7, 2, 14, 30, 0)
print(dt)

    Форматировать строку времени

    now = datetime.datetime.now()
formatted = now.strftime("%Y-%m-%d %H:%M:%S")
print(formatted)

    Разобрать строку времени

    dt_str = "2025-07-02 14:30:00"
parsed = datetime.datetime.strptime(dt_str, "%Y-%m-%d %H:%M:%S")
print(parsed)

    Сложение и вычитание времени

    now = datetime.datetime.now()
delta = datetime.timedelta(days=7)
next_week = now + delta
print(next_week)

    Получить сегодняшнюю дату

    today = datetime.date.today()
print(today)

    Сравнить даты

    dt1 = datetime.datetime(2025, 7, 1)
dt2 = datetime.datetime(2025, 7, 2)
print(dt1 < dt2)

    Получить разницу во времени

    dt1 = datetime.datetime(2025, 7, 1, 12, 0, 0)
dt2 = datetime.datetime(2025, 7, 2, 14, 30, 0)
diff = dt2 - dt1
print(diff)
print(diff.total_seconds())

    Получить день недели

    сегодня = дата-время.дата.сегодня()
print(today.weekday()) # 0 = понедельник, 6 = воскресенье

    проблема с часовым поясом datetime

    ошибка вычитания даты и времени с учетом смещения и смещения

    Когда один объект datetime не имеет часового пояса (наивный), а другой имеет часовой пояс (осведомлен) и вычитается, он выдает:

    TypeError: can't subtract offset-naive and offset-aware datetimes

    Проверьте, является ли datetime наивным или осведомленным

    from datetime import datetime

def is_aware(dt):
    return dt.tzinfo is not None and dt.tzinfo.utcoffset(dt) is not None

def is_naive(dt):
    return not is_aware(dt)

dt1 = datetime.now()                 # naive
dt2 = datetime.now().astimezone()    # aware

print(is_naive(dt1), is_aware(dt1))
print(is_naive(dt2), is_aware(dt2))

    Решение А. Преобразовать в осведомленный (рекомендуется)

    Подходит для ситуаций в разных часовых поясах или когда требуется точный расчет времени.

    из даты и времени импорта даты и времени, часового пояса

sql_dt = sql_dt.replace(tzinfo=timezone.utc) # поддержка передачи данных SQL
now_dt = datetime.now(timezone.utc) # Использовать информацию о текущем времени

разница = now_dt - sql_dt
печать(diff.total_секунды())

    Решение Б. Преобразование в простой формат (не рекомендуется, разница часовых поясов будет игнорироваться).

    sql_dt = sql_dt.replace(tzinfo=None)
now_dt = datetime.now()

diff = now_dt - sql_dt

    Подвести итог

    Вычислить стандартное отклонение ряда

    иллюстрировать

    В Python вы можете использовать встроенные модулиstatisticsизstdev()илиpstdev()Рассчитайте стандартное отклонение выборки или стандартное отклонение генеральной совокупности.

    пример

    статистика импорта

соотношения = [2,3, 2,8, 3,1, 2,5, 3,0]

# средний
среднее = сумма(отношения) / len(отношения)

#Выборочное стандартное отклонение (n-1)
std_sample = статистика.stdev(отношения)

#Стандартное отклонение матрицы (n)
std_population = статистика.pstdev(коэффициенты)

print(f"Среднее: {среднее:.2f}")
print(f"Стандартное отклонение выборки: {std_sample:.3f}")
print(f"Стандартное отклонение населения: {std_population:.3f}")

    Вывод результатов

    Средний: 2,74
Стандартное отклонение выборки: 0,303
Стандартное отклонение населения: 0,271.

    Метод формулы (без использования модов)

    Если вы не хотите полагаться наstatisticsМодуль, вы можете рассчитать самостоятельно, используя математические формулы:

    соотношения = [2,3, 2,8, 3,1, 2,5, 3,0]
среднее = сумма(отношения) / len(отношения)

#Стандартное отклонение (население)
дисперсия = sum((x - среднее) ** 2 для x в отношениях) / len(отношения)
std_dev = дисперсия ** 0,5

print(f"Стандартное отклонение: {std_dev:.3f}")

    Вывод результатов

    Стандартное отклонение: 0,271

    Описание разницы

    Подвести итог

    Python отображает цветовую строку ANSI

    базовый пример

    # Пример цветового кода ANSI
print("\033[31м красный текст\033[0м")
print("\033[32м зеленый текст\033[0м")
print("\033[33myellow text\033[0m")
print("\033[34м синий текст\033[0м")
print("\033[35м фиолетовый текст\033[0м")
print("\033[голубой текст длиной 36 м\033[0 м")
print("\033[37м белый текст\033[0м")

    Жирный шрифт и цвет фона

    print("\033[1;31м жирный красный текст\033[0м")
print("\033[42 м зеленый фоновый текст\033[0 м")

    Пользовательское сочетание цветов

    # Формат: \033[стиль; цвет переднего плана; цвет фона м
# Стиль: 0=по умолчанию, 1=жирный, 4=подчеркивание
# Цвет переднего плана: 30~37
# Цвет фона: 40~47

print("\033[1;33;44m жирный желтый текст + синий фон\033[0m")

    Может быть инкапсулирован в функции

    Защиту color_text(текст, color_code):
    верните f"\033[{color_code}m{text}\033[0m"

print(color_text("Внимание!", "1;31")) # Жирный красный
print(color_text("Успех!", "1;32")) # Жирный зеленый

    Проверьте, поддерживает ли текущий терминал цвета ANSI.

    Способ 1: проверьте sys.stdout.isatty()

    импортсистем

если sys.stdout.isatty():
    print("Терминал может поддерживать цвета ANSI")
еще:
    print("Это может быть файл или среда вывода, не поддерживающая цвет")

    Способ 2. Используйте Colorama (кроссплатформенное решение).

    импорт колорамы
колорама.init()

print("\033[32mЭтот текст должен быть зеленым\033[0m")

    Метод 3: Фактический результат теста

    защита support_ansi():
    попробуйте:
        print("\033[31м тестовый красный\033[0м")
        вернуть истину
    кроме:
        вернуть ложь

print("ANSI поддерживается", если support_ansi(), иначе "ANSI не поддерживается")

    Пополнить

    Ввод Python поддерживает автозаполнение

    иллюстрировать

    В Python,input()Сама функция не поддерживаетTabЗавершено автоматически. Для достижения этой функции вы можете объединитьreadlineМодуль, который позволяет пользователям использоватьTabВыполните автодополнение (аналогично Bash или IPython).

    базовый пример

    импортировать строку чтения

# Определить список строк, которые можно дополнить
СЛОВА = ['яблоко', 'банан', 'вишня', 'виноград', 'апельсин', 'арбуз']

def Completer(текст, состояние):
    """Функция автозаполнения: сравнение доступных строк на основе входных префиксов"""
    options = [w вместо w в WORDS, если w.startswith(text)]
    если состояние < Лен (варианты):
        варианты возврата [состояние]
    еще:
        возврат Нет

# Включить функцию завершения
readline.set_completer(завершитель)
readline.parse_and_bind('вкладка: завершена')

# Пользовательский ввод (поддерживает Tab)
user_input = input("Введите название фрукта (для завершения можно нажать Tab): ")
print(f"Вы ввели: {user_input}")

    Инструкция по эксплуатации

    Дополнительно: динамическое завершение

    Вы также можете обновить список завершения на основе текущего контекста или динамического содержимого:

    импортировать строку чтения

Защиту Dynamic_completer (текст, состояние):
    current_words = ['кошка', 'автомобиль', 'собака', 'утка', 'олень']
    options = [w вместо w в current_words, если w.startswith(text)]
    если состояние < Лен (варианты):
        варианты возврата [состояние]
    возврат Нет

readline.set_completer(dynamic_completer)
readline.parse_and_bind('вкладка: завершена')

команда = input("Введите имя животного: ")
print("Вы вводите:", команда)

    На что следует обратить внимание

    Подвести итог

    Python-процесс

    Цикл Python

    для с диапазоном()

    Самый распространенный цикл используется для запуска фиксированного количества раз или последовательности.

    # от 0 до 4
для меня в диапазоне (5):
    печать(я) #0,1,2,3,4

#Укажите начальную точку, конечную точку и размер шага
для я в диапазоне (2, 10, 2):
    печать(я) #2,4,6,8

    для с повторяемыми объектами

    Непосредственно перебирать списки, строки, словари и т. д.

    фрукты = ["яблоко", "банан", "вишня"]

для фруктов во фруктах:
    принт(фрукты)

для ch в «привет»:
    печать (ч)

#Перебор словаря
person = {"name": "Том", "возраст": 25}
для ключа значение в person.items():
    печать (ключ, значение)

    пока цикл

    Он всегда будет выполняться, если условие истинно.

    
count = 0
while count < 5:
    print(count)
    count += 1

    перерыв и продолжить

    Контролируйте процесс цикла.

    для меня в диапазоне (10):
    если я == 3:
        продолжить # пропустить этот раз
    если я == 7:
        перерыв # Закончить раньше
    распечатать(я)

    вложенный цикл

    Вернитесь в круг и поместите его обратно в круг.

    
for i in range(3):
    for j in range(2):
        print(f"i={i}, j={j}")

    Цикл сопоставления else

    Вы можете добавить либо на время, либо на времяelse, будет выполнено только «нормальное завершение (без перерыва)».

    для меня в диапазоне (5):
    распечатать(я)
еще:
    print("Цикл завершается нормально")

    Понимание списка

    Метод краткого письма позволяет завершить цикл и сгенерировать список в одну строку.

    
squares = [x**2 for x in range(5)]
print(squares)  # [0,1,4,9,16]

    в заключение

    Обработка исключений Python

    основная грамматическая структура

    Python использует оператор try...кроме для перехвата и обработки ошибок, возникающих во время выполнения программы, чтобы предотвратить ее сбой.

    попробуйте:
    # Код, который может вызывать исключения
    результат=10/0
кроме ZeroDivisionError:
    # Код, выполняемый при возникновении определенного исключения
    print("Делитель не может быть равен нулю")
кроме исключения как e:
    #Перехватываем все остальные типы исключений
    print(f"Произошла ошибка: {e}")
еще:
    # Выполнить, если в блоке try не возникает исключений
    print("работает нормально")
наконец:
    # Будет выполнено независимо от возникновения исключения
    print("Очистить ресурсы или закрыть файлы")

    Описание функции блока

    Перехват нескольких исключений

    Вы можете использовать кортежи в исключении для одновременной обработки нескольких типов ошибок.

    попробуйте:
    # Выполняем операции
    пройти
кроме (ValueError, TypeError):
    print("Введенный тип данных или значение неверен")

    Активно генерировать исключения

    Используйте ключевое слово raise, чтобы вручную инициировать исключения на основе логических требований.

    age = -1
if age < 0:
    raise ValueError("年齡數值不可為負數")

    лучшие практики

    Категории Python

    1. Основные понятия категорий

    Классы Python — это структуры, используемые для инкапсуляции данных и поведения. Категории используются для создания объектов, которые являются экземплярами категорий. Например:
    классМойКласс:
    def __init__(self, значение):
        self.value = значение

    Защитный дисплей (сам):
        print(f"Значение: {self.value}")

объект = МойКласс(10)
obj.display() # Вывод: Значение: 10

    2. Статический метод

    Статические методы определяются с помощью декоратора @staticmethod и не имеют ничего общего с категориями и объектами. Они не могут получить доступ к свойствам категории или свойствам объекта. Применяется к некоторым инструментальным функциям:

    класс МойКласс:
    @staticmethod
    Защиту добавить(а, б):
        вернуть а + б

результат = MyClass.add(5, 3)
print(result) # Вывод: 8

    3. Метод класса

    Методы класса определяются с помощью декоратора @classmethod, первым параметром является сам класс (обычно называемый cls), а к атрибутам класса можно получить доступ:

    класс МойКласс:
    количество = 0

    @classmethod
    защита приращения_count (cls):
        cls.count += 1

МойКласс.increment_count()
print(MyClass.count) # Вывод: 1

    4. Наследование и политип

    Python поддерживает наследование классов. Подклассы могут наследовать свойства и методы родительского класса и переопределять методы родительского класса:

    Родитель класса:
    защита приветствия (сам):
        print("Привет от родителя!")

класс Ребенок (Родитель):
    защита приветствия (сам):
        print("Привет от Чайлда!")

объект = Ребенок()
obj.greet() # Вывод: Привет от ребенка!

    5. Атрибуты категорий и атрибуты объектов

    Атрибуты категории принадлежат всей категории и являются общими для всех объектов; Атрибуты объекта принадлежат каждому объекту:

    класс МойКласс:
    class_attr = "Я атрибут класса"

    def __init__(self, значение):
        self.instance_attr = значение

obj1 = МойКласс(10)
obj2 = МойКласс(20)

print(MyClass.class_attr) # Вывод: я атрибут класса
print(obj1.instance_attr) # Вывод: 10
print(obj2.instance_attr) # Вывод: 20

    6. Используйте объект в качестве базового класса

    Все классы в Python по умолчанию наследуются от объекта, который является встроенным базовым классом, предоставляющим некоторые базовые методы, такие как __str__ и __eq__:

    класс MyClass (объект):
    def __init__(self, значение):
        self.value = значение

    защита __str__(сам):
        return f"MyClass со значением {self.value}"

объект = МойКласс(5)
print(obj) # Вывод: MyClass со значением 5

    7. Резюме

    - **Статический метод**: независимый от категорий, в основном используется для функций инструмента. - **Метод класса**: манипулирование данными на уровне категории. - **Метод объекта (метод экземпляра)**: манипулирование данными на уровне объекта. - **Наследование и политип**: поддержка повторного использования кода и гибкого дизайна. - **базовый класс объекта**: предоставляет базовые методы, обеспечивающие единообразное поведение всех категорий.

    Наследование классов

    1. Основные понятия наследования

    В Python наследование классов позволяет подклассам (производный класс) наследовать свойства и методы родительского класса (базовый класс) для повторного использования кода. Например:

    Родитель класса:
    защита приветствия (сам):
        print("Привет от родителя!")

класс Ребенок (Родитель):
    пройти

с = Ребенок()
c.greet() # Вывод: Привет от родителя!

    2. Подкласс переопределяет метод родительского класса.

    Подклассы могут переопределять (Override) методы родительского класса и переписывать его функции:

    Родитель класса:
    защита приветствия (сам):
        print("Привет от родителя!")

класс Ребенок (Родитель):
    защита приветствия (сам):
        print("Привет от Чайлда!")

с = Ребенок()
c.greet() # Вывод: Привет от ребенка!

    3. Используйте super() для вызова метода родительского класса.

    В подклассе вы можете вызвать метод родительского класса через super() и расширить поведение родительского класса:

    Родитель класса:
    защита приветствия (сам):
        print("Привет от родителя!")

класс Ребенок (Родитель):
    защита приветствия (сам):
        супер().приветствие()
        print("Привет от Чайлда!")

с = Ребенок()
c.greet()
# Вывод:
# Привет от Родителя!
# Привет от Чайлда!

    4. Множественное наследование

    Python поддерживает множественное наследование, а подклассы могут наследовать несколько родительских классов одновременно:

    класс Родитель1:
    защита приветствия (сам):
        print("Привет от Parent1!")

класс Родитель2:
    защита приветствия (сам):
        print("Привет от Parent2!")

класс Child(Parent1, Parent2):
    пройти

с = Ребенок()
c.greet() # Вывод: Привет от Parent1! (согласно очередности наследования)

    5. Порядок разрешения метода (MRO)

    Множественное наследование использует MRO (порядок разрешения методов) для определения порядка разрешения методов. Это можно проверить с помощью атрибута `__mro__`:

    печать(Child.__mro__)
# Вывод: (, , , )

    6. Абстрактный базовый класс

    Используйте модуль abc для определения абстрактного базового класса, чтобы заставить подклассы реализовывать определенные методы:

    из abc импорт ABC, абстрактный метод

класс AbstractParent(ABC):
    @abstractmethod
    защита приветствия (сам):
        пройти

класс Child(AbstractParent):
    защита приветствия (сам):
        print("Привет от Чайлда!")

с = Ребенок()
c.greet() # Вывод: Привет от ребенка!

    7. Резюме

    — Наследование делает код класса более пригодным для повторного использования и расширения. — Подклассы могут переопределять методы родительского класса и вызывать методы родительского класса с помощью super(). — Поддерживает множественное наследование, но необходимо обратить внимание на порядок разрешения методов (MRO). — Абстрактные базовые классы могут использоваться для того, чтобы заставить подклассы реализовывать определенные методы, что подходит для проектирования интерфейсов.

    Создайте временный класс, наследующий ClassB.

    Пример кода

    классКлассB:
    защита приветствия (сам):
        print("Привет из класса B!")

# Динамически создать временный класс, унаследованный от ClassB
TempClass = type('TempClass', (ClassB,), {
    'greet': лямбда self: (print("Привет от TempClass!"), super(TempClass, self).greet())[0]
})

#Создаем экземпляр и тестируем
темп = ТемпКласс()
temp.greet()

    объяснять

    1. функция типа():
      type('TempClass', (ClassB,), {...})
      - 'TempClass': новое имя категории.
      - (ClassB,): Кортеж базовых категорий, здесь есть только ClassB.
      - {...}: Новые атрибуты или методы.
    2. Лямбда-функции используются для переопределения методов:
      - НастроитьgreetМетод состоит в том, чтобы сначала распечатать новое сообщение, а затем передатьsuper()вызвать родительскую категориюgreet。

    Вывод результатов

    Hello from TempClass!
Hello from ClassB!

    Переключайтесь между использованием разных категорий с помощью одного и того же интерфейса.

    иллюстрировать

    Предположим, есть две категории.AClassиBClass, у них есть функции с одинаковым именем и параметрами. Мы хотим иметь возможность легко переключать используемые категории без необходимости изменения основной логики программы.

    Пример программы

    класс АКласс:
    процесс определения (я, данные):
        print(f"Обработка AClass: {data}")

    результат определения (сам):
        вернуть «результат из AClass»


класс BКласс:
    процесс определения (я, данные):
        print(f"Обработка BClass: {data}")

    результат определения (сам):
        вернуть «результат из BClass»


# Вы можете контролировать, какую категорию использовать, через настройки
USE_A = Истина

#Динамический выбор категорий
SelectedClass = AClass, если USE_A, иначе BClass

# Создайте экземпляр и используйте его
объект = ВыбранныйКласс()
obj.process("Тестовые данные")
печать(obj.result())

    Результаты вывода (USE_A=True)

    Обработка AClass: тестовые данные
Результаты AClass

    Вывод результатов (USE_A=False)

    Обработка BClass: тестовые данные
Результаты BClass

    Более продвинутый способ записи: использование заводской функции.

    защита get_class (имя):
    отображение = {
        «А»: Класс А,
        «Б»: BКласс
    }
    return Mapping.get(name, AClass) # По умолчанию — AClass

# Динамический выбор
cls = get_class("B")
объект = кл()
obj.process("Тестовые данные")

    в заключение

    Python использует абстрактные категории

    короткий ответ

    В Python,Не обязательно требуетсяНаписан как C++ или Javaabstract class. Python принимает «утиную типизацию». Пока объекты имеют одинаковые имена методов и поведение, их можно считать совместимыми.

    пример набора текста утки

    класс АКласс:
    процесс определения (я, данные):
        print(f"Обработка AClass: {data}")

класс BКласс:
    процесс определения (я, данные):
        print(f"Обработка BClass: {data}")

защита запуска (объект):
    obj.process("data") # Нет необходимости указывать тип, пока есть этот метод

запустить (АКласс())
запустить (BКласс())

    Вывод результатов

    Обработка класса A: данные
Обработка B-класса: данные

    Ситуации с использованием абстрактных категорий (ABC)

    Хотя Python не требует соблюдения типов, если вы хотите четко определить интерфейс при групповой разработке или больших проектах, вы можете использоватьabcМоды.

    из abc импорт ABC, абстрактный метод

класс BaseClass (ABC):
    @abstractmethod
    процесс определения (я, данные):
        пройти

класс AClass(БазовыйКласс):
    процесс определения (я, данные):
        print(f"Обработка AClass: {data}")

класс BClass(БазовыйКласс):
    процесс определения (я, данные):
        print(f"Обработка BClass: {data}")

# BaseClass() сообщит об ошибке, поскольку абстрактный метод не реализован

    в заключение

    Модули Python

    определение

    В Python,Модульэто файл, содержащий программный код, обычно с расширением файла.pyКонец. Модули могут определять функции, категории, переменные, а также могут содержать исполняемый код для облегчения повторного использования и структурирования программы.

    использовать

    Использование

    Python черезimportКлючевое слово для представления модуля, например:

    импорт математики

print(math.sqrt(16)) # Вывод 4.0

    Пользовательские модули

    Разработчики могут создавать свои собственные моды. Например, создайтеmymodule.py：

    
# mymodule.py
def greet(name):
    return f"Hello, {name}!"

    Используйте в другом файле программы:

    
import mymodule

print(mymodule.greet("Alice"))

    Общие встроенные группы

    Пакет Python

    определение

    В Python,УпаковкаЭто способ организации модулей. Пакет — это каталог, содержащий несколько модулей, что упрощает управление и обслуживание программы благодаря иерархической структуре.

    особенность

    базовый пример

    Создайте файл с именемmypackageКомплект:

    
mypackage/
│── __init__.py
│── module1.py
└── module2.py

    module1.pyпример:

    
def add(a, b):
    return a + b

    module2.pyпример:

    
def multiply(a, b):
    return a * b

    Используйте комплект

    импортировать mypackage.module1
импортировать mypackage.module2

print(mypackage.module1.add(2, 3)) # Вывод 5
print(mypackage.module2.multiply(2, 3)) # Вывод 6

    Импортируйте определенные проекты из пакета

    из импорта mypackage.module1 добавить
из mypackage.module2 импортировать умножить

print(add(10, 5)) # Вывод 15
print(multiply(10, 5)) # Вывод 50

    Обычное использование

    Получить текущее имя пакета

    иллюстрировать

    В Python, чтобы получить текущий модульИмя пакета, вы можете использовать специальные переменные__package__. Это и__module__Концепция получения текущего имени модуля аналогична.

    Пример: структура модуля и комплекта

    
mypackage/
│── __init__.py
└── submodule.py

    submodule.pyсодержание:

    
print("__name__:", __name__)
print("__package__:", __package__)
print("__module__:", __module__)

    Результат выполнения

    Если используется в других программах какimport mypackage.submoduleИмпортируйте, результат примерно следующий:

    
__name__: mypackage.submodule
__package__: mypackage
__module__: __main__

    объяснять

    Сценарии применения

    Версия пакета Python

    Есть два основных способа проверить версию пакета Python: через терминал (командную строку) или запустив его в коде Python. Это поможет вам убедиться, соответствует ли среда требованиям проекта.

    1. Проверка через терминал (Командная строка)

    Это самый быстрый метод, не требующий входа в интерактивную среду Python.

    2. Проверьте код Python

    Если вам необходимо определить версию при выполнении программы, вы можете использовать следующие два метода:

    3. Сравнительная таблица методов контроля

    метод Инструкции/Код Применимые ситуации
    Пип-команда pip show Просмотр подробной информации, такой как путь установки, автор, зависимости и т. д.
    Список пипов pip list Получите краткий обзор всех пакетов и версий в вашей текущей среде.
    внутренние свойства .__version__ Делайте логические выводы во время работы сценария.
    Metadata version() Стандартизированный способ проверки без загрузки всего пакета.

    4. Проверьте собственную версию Python

    Иногда проблема не в пакете, а в самом интерпретаторе Python:

    5. Часто задаваемые вопросы и напоминания

    Получить имя пакета из категории и объекта модуля.

    Объект класса

    В Python доступ к объектам классов можно получить черезcls.__module__Найдите имя модуля, определяющего категорию, а затем используйтеsys.modulesПолучите объект модуля и, наконец, прочитайте его.__package__Свойство для получения имени пакета.

    импортсистем

# Предположим, что категория определена в mypackage.submodule
классМойКласс:
    пройти

# Получить имя модуля, к которому принадлежит категория
имя_модуля = МойКласс.__модуль__
print("Имя модуля:", имя_модуля)

# Получить объект модуля
mod = sys.modules[имя_модуля]

# Получите имя пакета из объекта модуля
print("Имя пакета:", mod.__package__)

    Объект модуля

    Сам модуль является объектом, и к нему можно получить прямой доступ.__package__свойство.

    импорт математики
импортировать mypackage.submodule как подмодуль

# math — это стандартный модуль библиотеки функций, пакета нет, поэтому __package__ — пустая строка
print("math.__package__:", math.__package__)

# Модули для пользовательских комплектов
print("sub.__package__:", sub.__package__)

    Пример результата выполнения

    Имя модуля: mypackage.submodule
Имя пакета: мойпакет
math.__package__:
sub.__package__: мой пакет

    в заключение

    inspect.getfile

    Когда файл Python выполняется напрямую, имя его модуля —__main__. Это делает использование толькоcls.__module__Невозможно получить исходное имя и путь к файлу.

    Предположим, что структура вашего проекта:

    /проект
  |-- test_runner.py <-- Файл, который вы запускаете напрямую (будет рассматриваться как __main__)
  |-- тест/
        |-- db_test.py <-- Файл, определяющий DbCmdAgent

    Если вы выполните следующий код в `test_runner.py`:

    из test.db_test импортировать DbCmdAgent
Agent_obj = DbCmdAgent(...) # Создание экземпляра

# В настоящее время cls.__module__ по-прежнему имеет значение «test.db_test» (правильное имя модуля)

    Однако, если вы определите категории в `test_runner.py`:

    # Содержимое test_runner.py
класс DbCmdAgent:
    пройти

агент_объект = DbCmdAgent()
#В настоящее время cls.__module__ == '__main__' (неверное имя модуля)

    Это означает, что класс, для которого вы получаете информацию, определен в файле, который исполняется как `__main__`.

    использоватьinspectМодуль может напрямую получить путь к файлу

    Независимо от того, определена ли категория в `__main__`, вы можете обойти атрибут `__module__` и использоватьinspectмодуль, чтобы получить путь к файлу исходного кода, соответствующий этой категории. Это более надежный и универсальный метод.

    Исправленная реализация Python

    импортная проверка
импортировать ОС

# --- Ситуация моделирования: категории, определенные в __main__ (исполняемый в данный момент скрипт) ---

класс DbCmdAgent:
    """Эта категория определена в исполняемом в данный момент основном скрипте"""
    def __init__(сам, данные):
        self.data = данные

Agent_obj = DbCmdAgent("некоторые_данные")

защита get_class_location_robust(obj):
    """
    Используйте Inspect.getfile, чтобы обойти проблему __module__ == '__main__'.
    """
    cls = тип (объект)
    
    # 1. Используйте Inspect.getfile(), чтобы получить путь к файлу, определяющему категорию.
    попробуйте:
        путь_файла = проверить.getfile(cls)
        
        # 2. Получите имя файла и каталог
        имя_файла = os.path.basename(путь_файла)
        каталог = os.path.dirname(путь_файла)
        py_name = os.path.splitext(имя_файла)[0]
        
        # 3. Если __module__ — это __main__, замените его именем архива, чтобы предоставить больше контекста.
        имя_модуля = cls.__module__
        если имя_модуля == '__main__':
            имя_модуля = имя_py_# Используйте db_test или test_runner в качестве контекста
            
    кромеТипОшибка:
        # Обработка встроенных типов
        file_path = "Н/Д (встроенное расширение или расширение C)"
        имя_файла = "Н/Д"
        каталог = "Н/Д"
        py_name = "Н/Д"
        имя_модуля = cls.__module__
        
    вернуть {
        "имя_модуля_или_основной": имя_модуля,
        "py_name_no_ext": py_name,
        «каталог»: каталог,
        «путь_файла»: путь_файла,
    }

# Выполняем и просматриваем результаты
location_info = get_class_location_robust(agent_obj)

print("--- Информация о файле определения категории ---")
print(f"Имя файла (имя .py): {location_info['py_name_no_ext']}")
print(f"Путь к каталогу (Пакет): {location_info['directory']}")
print(f"Полный путь к файлу: {location_info['file_path']}")

    4. Краткое изложение ключевых моментов

    Модуль динамического импорта

    Описание функции

    Этот метод используетimportlib.import_moduleПопробуйте импортировать указанный модуль. Если вы столкнетесьModuleNotFoundError, попытается импортировать свои подмодули из текущего загруженного пакета.

    Пример программы

    импортировать импортную библиотеку
импортсистем

защита Safe_import (имя_модуля):
    попробуйте:
        # Попробуйте импортировать напрямую
        вернуть importlib.import_module(имя_модуля)
    кроме ModuleNotFoundError:
        # Если не удалось, попробуйте импортировать подмодуль из известного пакета
        для пакета в списке (sys.modules.keys()):
            если pkg, а не pkg.startswith("_"):
                попробуйте:
                    return importlib.import_module(f"{pkg}.{module_name}")
                кроме ModuleNotFoundError:
                    продолжать
        поднять # Если все еще не найдено, выдать исключение

    Примеры использования

    импортировать число

mod1 = Safe_import("random") # Это может быть успешным, потому что это стандартная библиотека
mod2 = Safe_import("linalg") # Попробую numpy.linalg
print(mod2.__name__) # Вывод numpy.linalg

    иллюстрировать

    Путь поиска модуля Python: состав sys.path

    В Python,sys.path— это список, содержащий все пути к каталогам, которые интерпретатор Python будет искать по порядку при попытке импортировать модуль. Когда вы выполняетеimport some_module, Python проверит по порядкуsys.pathкаждый каталог в списке, пока не найдете каталог с именемsome_moduleфайлы (например,some_module.py、some_module/__init__.pyждать).

    Три основных компонента sys.path

    sys.pathСписки обычно состоят из следующих трех частей и ищутся в следующем порядке:

    1. Каталог входа (точка входа) программного кода.

    2. Переменная среды PYTHONPATH.

    3. Стандартная библиотека функций и каталог установки.

    ---

    Системные переменные, связанные с sys.path

    В дополнение к вышесказанномуPYTHONPATHКроме того, существует несколько переменных среды, связанных со средой выполнения Python, которые влияют на поведение интерпретатора и поиск пути, но влияютsys.pathОсновные переменные, составляющиеPYTHONPATH：

    Системные переменные Описание функции Связь с sys.path
    PYTHONPATH Определяет дополнительные каталоги, которые будут добавлены в путь поиска модов. прямое воздействиеsys.pathсостав.
    PYTHONHOME Используется для установки альтернативного пути к каталогу установки Python, особенно для встроенных систем. Косвенно влияет на стандартную библиотеку иsite-packagesрасположение.
    PATH Используется операционной системой для поиска исполняемых файлов (например,python.exe) путь. не влияет напрямуюsys.path, но влияет на то, какой интерпретатор Python выполняется.
    VIRTUAL_ENV Когда вы находитесь в виртуальной среде, эта переменная указывает на корневой каталог виртуальной среды. косвенное воздействиеsys.path, поскольку это обеспечиваетsite-packagesОно исходит из виртуальной среды, а не всей системы.

    Как изменить sys.path

    потому чтоsys.path— это обычный список Python, который вы можете динамически изменять во время работы программы, но такие изменения вступают в силу только в рамках текущего сеанса интерпретатора:

    импортсистем
импортировать ОС

# Добавьте родительский каталог в путь поиска (обычно используется для тестирования или внутренней ссылки на проект)
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

    Мод Тень

    Затенение модулей (или затенение имен) — распространенная ошибка или проблема программирования в Python. Это происходит, когда вы случайно создаете файл кода или имя переменной, которое конфликтует с именем встроенного модуля или сторонней библиотеки, которую вы пытаетесь импортировать или использовать.

    1. Определение и причины возникновения

    В результате ваш локальный файл «закрывает» или «переопределяет» стандартный модуль, который должен быть загружен, что делает ваш код неспособным получить доступ к функциям стандартного модуля (например,socket.AF_UNSPEC) завершится ошибкой, поскольку загруженный вами локальный файл не имеет этих свойств.

    2. Распространенные примеры

    Имя стандартного модуля Имя локального файла, вызвавшего тень в результате
    socket socket.py Невозможно использовать стандартныйsocketСетевые константы модуля (например,AF_INET, AI_PASSIVE）。
    json json.py Невозможно использовать стандартныйjsonМодульныйloadsилиdumpsфункция.
    test(название проекта) test.py В среде модульного тестирования могут возникнуть конфликты с внутренней логикой среды тестирования.

    3. Решение

    1. Переименуйте архив: Это самое простое и эффективное решение. Просто переименуйте локальные файлы или каталоги, которые конфликтуют со стандартными именами модулей или библиотек. Например, изменитьsocket.pyпереименованnetwork_handler.py。
    2. Проверьте sys.path: сделайте это в своем кодеimport sys; print(sys.path)Проверьте путь поиска Python, чтобы убедиться, что он загружает ваши локальные файлы вместо каталога стандартной библиотеки.
    3. Используйте виртуальную среду. Хотя виртуальная среда сама по себе не предотвращает теневое копирование локальных архивов, она может гарантировать, что устанавливаемые вами сторонние пакеты не будут конфликтовать с другими средами.

    Получить имя текущей записи .py

    иллюстрировать

    Чтобы получить текущее выполнение программы Python__main__Имя файла .py, которому он принадлежит, которое можно использовать.__main__.__file__илиsys.argv[0]. Но в интерактивном режиме Jupyter или-cМожет не существовать во время выполнения и поэтому требует безопасного обращения.

    Получить текущее имя основного файла .py (безопасная версия)

    импортировать ОС
импортсистем
импортировать __main__

защита get_main_py_path():
    """Возвращает абсолютный путь к файлу .py, которому принадлежит main. Если его невозможно найти, возвращается None"""

    # Случай 1: Нормальное выполнение .py
    main_file = getattr(__main__, "__file__", нет)
    если основной_файл:
        вернуть os.path.abspath(main_file)

    # Случай 2: Решение sys.argv[0]
    если len(sys.argv) > 0:
        argv0 = sys.argv[0]
        если argv0 отсутствует ("", "-c", ""):
            кандидат = os.path.abspath(argv0)
            если os.path.exists(кандидат):
                возвратный кандидат

    # Случай 3: Интерактивный режим, Jupyter, встраивание и т. д.
    возврат Нет

# Пример
путь = get_main_py_path()
если путь:
    print("Основной путь:", путь)
    print("основное имя файла:", os.path.basename(path))
еще:
    print("main.py не найден (возможно, в интерактивной среде или не запущен из архива)")

    Просто имя файла (базовое имя)

    path = get_main_py_path()
filename = os.path.basename(path) if path else None
print(filename)

    Подвести итог

    Получить имена параметров и значения текущей функции

    To get the parameter names and their corresponding values of a function in Python, you can use the `inspect` module, which provides introspection utilities. Specifically, `inspect.signature()` can help you retrieve the names of the parameters, and you can pass the current frame's local variables to get their values.

Here is an example that demonstrates how to get the function name, parameter names, and their values:

```python
import inspect

# Sample function
def my_function(a, b, c=5):
    # Get the current frame
    frame = inspect.currentframe()
    
    # Get the function name
    func_name = frame.f_code.co_name
    print(f"Function name: {func_name}")
    
    # Get the parameter names and their values
    args, _, _, values = inspect.getargvalues(frame)
    
    # Print parameter names and values
    for arg in args:
        print(f"Parameter name: {arg}, Value: {values[arg]}")

# Call the function
my_function(1, 2)
```

### Output:
```
Function name: my_function
Parameter name: a, Value: 1
Parameter name: b, Value: 2
Parameter name: c, Value: 5
```

### Explanation:
1. **`inspect.currentframe()`**: Retrieves the current execution frame.
2. **`frame.f_code.co_name`**: Extracts the name of the current function.
3. **`inspect.getargvalues(frame)`**: Gets the argument names and their corresponding values from the frame. This function returns a tuple containing:
   - `args`: List of argument names.
   - `_`: Placeholder for unused information.
   - `values`: Dictionary containing argument names as keys and their values.

This allows you to print both the names of the function's parameters and their values at runtime.

    Получить тип параметров функции

    Использование модуля проверки

    В Python вы можете использоватьinspect.signature()Получить информацию о параметрах функции, и дальше отParameter.annotationСвойство получает аннотацию типа (подсказку типа) для каждого параметра.

    импортная проверка

def my_function(a: int, b: str, c: float = 3.14) -> bool:
    вернуть ул(а) == б

сиг = проверить.подпись(my_function)

для имени, параметра в sig.parameters.items():
    print(f"Имя параметра: {имя}")
    print(f"Значение по умолчанию: {param.default}")
    print(f"Введите аннотацию: {param.annotation}")
    печать()

    Вывод результатов

    Имя параметра: а
  По умолчанию: <class 'inspect._empty'>
  Введите аннотацию: <class 'int'>

Имя параметра: б
  По умолчанию: <class 'inspect._empty'>
  Введите аннотацию: <class 'str'>

Имя параметра: c
  По умолчанию: 3.14
  Введите аннотацию: <class 'float'>

    иллюстрировать

    Используйте get_type_hints

    Этот метод автоматически разрешает прямые ссылки (типы, помеченные как строки).

    
from typing import get_type_hints

hints = get_type_hints(my_function)
print(hints)

    Вывод результатов

    
{'a': <class 'int'>, 'b': <class 'str'>, 'c': <class 'float'>, 'return': <class 'bool'>}

    Подвести итог

    Получить имя класса объекта

    иллюстрировать

    В Python вы можете использовать объект__class__атрибут илиtype()функция, Получите категорию (класс), к которой он принадлежит, а затем получите имя категории.

    пример

    класс Животное:
    пройти

класс Собака(Животное):
    пройти

объект = Собака()

#Метод 1: Используйте __class__.__name__
print(obj.__class__.__name__) # Вывод: Собака

#Метод 2: использовать type()
print(type(obj).__name__) # Вывод: Собака

#Метод 3. Получите полное имя модуля и категории.
print(obj.__class__) # Вывод: <class '__main__.Dog'>
print(obj.__class__.__module__) # Вывод: __main__

    Вывод результатов

    
Dog
Dog
<class '__main__.Dog'>
__main__

    иллюстрировать

    Расширенные приложения

    Чтобы одновременно получить полное «имя модуля + категории», вы можете написать:

    
cls = type(obj)
full_name = f"{cls.__module__}.{cls.__name__}"
print(full_name)

    Вывод результатов

    
__main__.Dog

    Подвести итог

    Определить категорию, к которой принадлежит атрибут

    Ниже приведен пример кода, который использует Python для определения того, к какому классу наследования принадлежит свойство:

    Пример кода

    импортная проверка

класс Базовыйкласс:
    base_attr = "Я атрибут из BaseClass"

Подкласс класса (Базовыйкласс):
    sub_attr = "Я атрибут из подкласса"

# Определить функцию для поиска категории, к которой принадлежит атрибут
защита find_attribute_owner(cls, attr_name):
    для базы в Inspect.getmro(cls): # Получить MRO (порядок разрешения метода)
        если attr_name в base.__dict__:
            возвратная база
    возврат Нет

# тест
sub_obj = Подкласс()
атрибуты = sub_obj.__class__.__dict__.items() # Получить все атрибуты на уровне категории
для имени, значения в атрибутах:
    владелец = find_attribute_owner(sub_obj.__class__, имя)
    print(f"Атрибут '{name}' принадлежит категории: {owner.__name__}")

    Описание программы

    Результат выполнения

    Для категорий в примере результаты выполнения следующие:

    Атрибут «__module__» принадлежит классу: SubClass.
Атрибут «sub_attr» принадлежит классу: SubClass.
Атрибут «__doc__» принадлежит классу: SubClass.
Атрибут «base_attr» принадлежит классу: BaseClass.

    Получить аннотацию функции (Docstring)

    Используйте __doc__

    class MyClass:
    def fun1(self):
        '''
        Fun1 comment
        '''
        pass

obj = MyClass()
print(obj.fun1.__doc__)

    Использование модуля проверки

    import inspect

class MyClass:
    def fun1(self):
        '''
        Fun1 comment
        '''
        pass

print(inspect.getdoc(MyClass.fun1))

    Функция помечена как устаревшая

    Использование модуля предупреждений

    В Python вы можете использовать встроенныйwarningsМодули, которые предупреждают пользователей во время выполнения (а не во время компиляции) о том, что функция устарела, и предлагают новые альтернативы.

    импортировать предупреждения

защита old_function(x, y):
    предупреждения.предупреждать(
        «Функция old_function() устарела, используйте вместо нее new_function(x, y).»,
        категория = Предупреждение об устаревании,
        уровень стека = 2
    )
    вернуть х + у

защита new_function(x, y):
    вернуть х + у

    Пример выполнения

    
result = old_function(3, 4)
print(result)

    Вывод результатов

    Предупреждение об устаревании: функция old_function() устарела, вместо нее используйте new_function(x, y).
  результат = старая_функция (3, 4)
7

    Дополнительная информация

    Дополнительно: Создайте декоратор для автоматической пометки устаревших функций.

    Декораторы можно использовать, чтобы позволить нескольким старым функциям использовать одну и ту же логику запроса на прекращение поддержки:

    импортировать предупреждения
из оберток импорта functools

защита устарела (новое_имя_функции):
    декоратор защиты (функция):
        @wraps(функция)
        def-обертка(*args, **kwargs):
            предупреждения.предупреждать(
                f"Функция {func.__name__}() устарела, используйте вместо нее {new_func_name}().",
                категория = Предупреждение об устаревании,
                уровень стека = 2
            )
            return func(*args, **kwargs)
        возвратная обертка
    вернуть декоратор

@deprecated("новая_функция")
защита old_function(x, y):
    вернуть х + у

    Разница между @staticmethod и @classmethod

    В Python,@staticmethodи@classmethodОба декоратора могут определять методы, которые можно вызывать без создания экземпляра класса, но их назначение и поведение различаются.

    @staticmethod

    Пример @staticmethod:

    класс МойКласс:
    @staticmethod
    защита static_method(x, y):
        вернуть х + у

# Статические методы можно вызывать без создания экземпляра
result = MyClass.static_method(5, 10) # Результат: 15

    сосредоточиться：@staticmethodКатегория недоступна (cls) или экземпляр (self）。

    @classmethod

    Пример @classmethod:

    классМойКласс:
    класс_переменная = 0

    def __init__(self, значение):
        self.value = значение
        MyClass.class_variable += 1

    @classmethod
    защита get_class_variable (cls):
        вернуть cls.class_variable

#Создать экземпляр
obj1 = МойКласс(10)
obj2 = МойКласс(20)

# Метод категории вызова
print(MyClass.get_class_variable()) # Результат: 2

    сосредоточиться：@classmethodМожет получить доступ к статусу уровня категории (cls）。

    Подвести итог

    особенность @staticmethod @classmethod
    первый параметр Нет неявного первого аргумента cls(сама категория)
    экземпляр доступа никто никто
    Категория доступа никто иметь
    использование Служебные функции, связанные с категориями, но не требующие экземпляров или категорий. Необходимо манипулировать данными уровня категории или предоставить альтернативные конструкторы.

    Статический класс выполняет инициализацию

    Сам Python не предоставляет «статический метод по умолчанию» или «метод класса по умолчанию», то есть функцию автоматического выполнения метода при первом вызове любого статического метода или метода класса. Но мы можем добиться аналогичного поведения с помощью методов ленивой загрузки.

    Решение: используйте статические переменные и отложенную загрузку.

    Вы можете определить статическую переменную в классе для отслеживания инициализированного состояния, а затем выполнить логику инициализации при первом вызове статического метода или метода класса.

    пример:

    класс МойКласс:
    инициализирован = False # Статическая переменная, отслеживающая, была ли она инициализирована

    @staticmethod
    защита init_once():
        если не MyClass.initialized:
            print("Выполнение логики инициализации...")
            MyClass.initialized = Истина

    @classmethod
    защита class_method (cls):
        cls.init_once()
        print("Вызов метода класса")

    @staticmethod
    защита static_method():
        МойКласс.init_once()
        print("Вызвать статический метод")

# Вызовите метод категории в первый раз, чтобы запустить инициализацию
MyClass.class_method() # Вывод: выполнение логики инициализации... Вызов метода класса

# Вызываем метод категории второй раз и больше не выполняем инициализацию
MyClass.class_method() # Вывод: вызов метода класса

# При первом вызове статического метода инициализация не выполняется, поскольку он уже инициализирован.
MyClass.static_method() # Вывод: вызов статического метода

    Как это работает:

    Подвести итог

    Хотя Python не имеет встроенного «статического метода по умолчанию» или «метода класса по умолчанию», с помощью статических переменных и методов отложенной загрузки вы можете автоматически выполнять логику инициализации при первом вызове статического метода или метода класса и гарантировать, что эта логика будет выполнена только один раз.

    Python-поток

    В Python поток — это механизм, используемый для реализации параллелизма. Это позволяет программе выполнять несколько задач одновременно в рамках одного процесса (Процесса). Это очень полезно для выполнения операций с интенсивным вводом-выводом (таких как сетевое соединение, чтение и запись файлов) и может предотвратить блокировку программы (блокировку) в ожидании завершения внешних операций.

    1. Зачем использовать потоки?

    2. Ограничения потоков Python: GIL (глобальная блокировка интерпретатора)

    В стандартном интерпретаторе CPython имеется «Глобальная блокировка интерпретатора» (Global Interpreter Lock, GIL). GIL гарантирует, что только один поток может выполнять биткод Python в любой момент времени. Это означает:

    3. Модуль потока выполнения:threading

    Python использует стандартную библиотеку функцийthreadingМодуль для обработки потоков выполнения. Существует два основных метода создания потоков:

    Способ 1: передать функцию как цель (целевая функция)

    Это самое простое и распространенное использование.

    импорт потоков
время импорта

задача def (имя, задержка):
    """Целевая функция, выполняемая потоком"""
    print(f"Тема {имя}: Начало...")
    time.sleep(delay) # Имитация трудоемких операций ввода-вывода
    print(f"Тема {name}: Задача выполнена.")

#Создаем поток выполнения
thread1 = threading.Thread(target=task, args=("T1", 2))
thread2 = threading.Thread(target=task, args=("T2", 4))

# Начать ветку
поток1.start()
поток2.start()

# Дождитесь завершения всех потоков (заблокируйте основной поток, пока они не завершатся)
поток1.join()
поток2.join()

print("Все потоки выполнения завершены. Основная программа завершается.")

    Способ 2: Наследованиеthreading.Threadкатегория

    Подходит для более сложных сценариев, инкапсулируя логику потока выполнения в категорию.

    импорт потоков
время импорта

класс MyThread(threading.Thread):
    def __init__(я, имя, задержка):
        супер().__init__()
        self.name = имя
        self.delay = задержка

    защита запуска (сам):
        """
        При запуске потока автоматически вызывается метод run().
        Здесь вы определяете задачи, которые будет выполнять поток.
        """
        print(f"Поток {self.name}: Начало...")
        time.sleep(self.delay)
        print(f"Тема {self.name}: Задача выполнена.")

#Создаем и запускаем поток
поток3 = МойПоток("T3", 3)
поток3.start()
поток3.join()

print("Пользовательский поток выполнения завершен.")

    4. Синхронизация потоков и обмен данными

    Когда несколько потоков получают доступ к общим данным и изменяют их, могут возникнуть условия гонки. Вам необходимо использовать механизм синхронизации для защиты ваших данных:

    Использование примера блокировки

    импорт потоков

# Общие ресурсы
счетчик = 0
# Создать блокировку
блокировка = резьба.Lock()

защита приращения_счетчика():
    глобальный счетчик
    # Получите блокировку, чтобы гарантировать, что только один поток может выполнить этот блок одновременно
    блокировка.приобретать()
    попробуйте:
        # Раздел соревнований
        текущее_значение = счетчик
        time.sleep(0.001) # Имитация переключения
        счетчик = текущее_значение + 1
    наконец:
        # Снять блокировку
        блокировка.выпуск()

темы = []
для меня в диапазоне (100):
    t = threading.Thread(target=increment_counter)
    потоки.append(т)
    т.старт()

за т в темах:
    t.join()

print(f"Окончательное значение счетчика: {counter}") # Если блокировки нет, это значение не может быть 100

    Запуск, синхронизация и остановка потоков Python

    ПитонthreadingМодуль предоставляет функцию создания и управления потоками выполнения, но из-за ограничений операционной системы и философии проектирования Python не предоставляет безопасный, прямой и принудительный метод остановки (уничтожения) внешних потоков выполнения. Принудительная остановка может привести к утечке ресурсов или повреждению данных.

    Следовательно, остановка потока выполнения должна достигаться с помощью **Механизма сотрудничества****, то есть позволяя потоку выполнения самостоятельно проверять флаг остановки и корректно завершать работу.

    1. Механизм остановки потока: использование флагов (Flag)

    Это самый безопасный и наиболее рекомендуемый метод остановки потока. Он требует, чтобы поток периодически проверял внешнюю переменную (флаг) в цикле выполнения задачи.

    Примеры реализации Python

    импорт потоков
время импорта

# Общий флаг остановки
stop_flag = поток.Событие()

def Monitored_task (имя, задержка):
    """
    Функция задачи, которая периодически проверяет флаг остановки.
    """
    print(f"Тема {имя}: Начало...")
    я = 0
    while not stop_flag.is_set(): # Проверяем, установлен ли флаг
        я += 1
        print(f"Поток {name}: шаг выполнения {i}")
        
        # Моделируйте трудоемкие операции и регулярно проверяйте
        time.sleep(задержка)
        
        # Здесь вы можете установить ограничение на количество выполнений, чтобы не было бесконечного цикла
        если я >= 5:
            сломать
            
    print(f"Поток выполнения {name}: получил сигнал остановки или задача завершилась и корректно завершился.")

# --- Главный блок управления программой ---

#Создаем поток выполнения
worker_thread = threading.Thread(target=monitored_task, args=("Worker-1", 1))

# Начать ветку
рабочий_поток.start()

print("\nОсновная программа: поток выполнения запущен, подождите 3 секунды...\n")
time.sleep(3) # Пусть поток поработает некоторое время

# Отправить сигнал остановки
print("\nОсновная программа: Установить флаг остановки...\n")
stop_flag.set() # Установить событие и позволить is_set() вернуть True

# Подождите, пока поток корректно завершится и завершится (обычно быстро)
рабочий_поток.join()

print("\nОсновная программа: поток благополучно остановлен и присоединен. Программа завершена.")

    2. Описание ключевых компонентов

    3. Другие механизмы остановки (принудительная остановка не рекомендуется)

    Хотя существуют некоторые экспериментальные или небезопасные способы принудительной остановки, такие как использование `_thread.stop()` или создание исключения, эти методы могут привести к:

    Поэтому в Python вам всегда следует использовать скоординированный механизм пометки для остановки потоков.

    Решение многопоточного конфликта общих объектов

    1. Наиболее часто используемое решение: локальное хранилище потоков.

    Это наиболее рекомендуемый подход в многопоточных средах. Вместо того, чтобы все потоки захватывали один и тот же объект, каждый поток имеет независимую копию объекта. В Python вы можете использоватьthreading.local()достичь.

    импорт потоков

# Создайте область потока для хранения объектов
thread_data = threading.local()

защита get_service():
    # Если текущий поток не имеет собственного сервиса, создайте его
    если нет, hasattr(thread_data, 'service'):
        print(f"Создать новое соединение для потока {threading.current_thread().name}")
        thread_data.service = create_new_connection()
    вернуть поток_данных.сервис

задача определения():
    сервис = get_service()
    # Выполняем операции...

    2. Второй по распространенности способ: запорный механизм (Locking).

    Если объект должен быть одинаковым (например, запись в один и тот же файл или работа с одним и тем же глобальным счетчиком), вы должны использоватьLock. Это гарантирует, что только один поток может одновременно получить доступ к объекту, избегая условий гонки.

    блокировка = резьба.Lock()

защита Safe_task():
    с замком:
        # Внутри этого блока другие потоки должны ждать
        общий_объект.do_something()
    ---

    Альтернативы многопоточности: асинхронная и многопроцессорная обработка

    Если вы хотите избежать риска конфликтов блокировок или сбоев, связанных с несколькими потоками, следует рассмотреть две основные альтернативы:

    1. Асинхронные сопрограммы (Asyncio) — подходят для задач с интенсивным вводом-выводом.

    В настоящее время это самый популярный подход в Python (например, основной принцип FastAPI). Он работает в одном потоке и ожидает ввода-вывода (например, запросов API, запросов к базе данных), переключая задачи.

    импортировать асинхронный код

асинхронная защита fetch_api (url):
    # Используйте асинхронные библиотеки, такие как aiohttp
    ответ = ожидайте call_api (url)
    обратный ответ

асинхронное определение main():
    # Выполнять несколько задач одновременно, но переключаться внутри одного потока
    результаты = ждут asyncio.gather(fetch_api("url1"), fetch_api("url2"))

    2. Многопроцессорность – подходит для задач с интенсивными вычислениями.

    Поток выполнения Python ограничен GIL (глобальной блокировкой интерпретатора) и не может по-настоящему распараллеливать операции.multiprocessingБудет открыто несколько независимых экземпляров интерпретатора Python.

    из многопроцессорного процесса импорта

задача определения (имя):
    print(f"Процесс {name} выполняется")

если __name__ == "__main__":
    p = Процесс(цель=задача, args=('A',))
    п.старт()
    p.join()

    3. Очередь задач – подходит для распределенной обработки.

    Если вы хотите полностью разделить задачи, вы можете использовать Celery или Redis Queue. Поместите задачу в очередь и позвольте внутреннему работнику (который может представлять собой несколько процессов или несколько компьютеров) подобрать и выполнить ее.

    ---

    Сводные предложения

    план Решение Применимые ситуации
    Thread-Local Каждый поток получает копию Служба API, подключение к базе данных
    Asyncio Однопоточное переключение (несинхронное) Высокое число одновременных сетевых запросов (рекомендуется)
    Multiprocessing независимое пространство памяти Вычисления на ЦП, полностью избегая конфликтов совместного использования

    Баланс между хранением области потоков и обменом информацией

    основные понятия

    Когда вы используете локальное хранилище потоков (TLS), цель состоит в том, чтобы защитить эти «непотокобезопасные» объекты (такие как служба API, подключения к базе данных). Но если между потоками необходимо обмениваться данными (например, результаты, загруженные потоком А, необходимо обработать потоком Б), необходимо установить специальный «канал связи».

    1. Используйте потокобезопасные очереди (Queue) — наиболее рекомендуется.

    Питонqueue.QueueЯвляется ли потокобезопасным. Это самый стандартный и безопасный способ передачи информации между потоками. Он уже обработал всю логику блокировки внутри себя.

    импорт потоков
очередь импорта

# Создайте глобальную очередь, к которой будут иметь доступ все потоки выполнения
Task_queue = очередь.Очередь()

Защитный продюсер():
    # Производим данные и помещаем их в очередь
    data = {"video_id": "abc", "status": "pending"}
    Task_queue.put (данные)

защита потребителя():
    # Получаем данные из очереди
    данные = Task_queue.get()
    # Обработка данных...
    Task_queue.task_done()

    2. Используйте переменные безопасности потока (например, блокировку общего списка).

    Если вам нужно поделиться большим списком или словарем, вы можете использовать общие глобальные переменные, но доступ к ним должен осуществляться с помощью сопоставления.threading.Lock。

    общие_результаты = []
results_lock = резьба.Lock()

задача определения():
    result = "Результаты некоторых операций"
    
    #Блокировка перед доступом к общим ресурсам
    с результатами_блокировки:
        shared_results.append(результат)
    # Автоматически разблокировать после выхода из блока with

    3. Используйте объекты «Событие» или «Условие» (синхронизация сигналов).

    Иногда вы хотите делиться не «данными», а «состоянием» (например, сообщать другим потокам, что API инициализирован).

    api_ready = резьба.Событие()

инициализатор защиты():
    #Выполняем инициализацию
    api_ready.set() # Отправить сигнал

рабочий рабочий():
    api_ready.wait() # Ждем сигнала, пока инициализатор не вызовет set()
    print("Начнём работать")

    Резюме: Региональное хранилище и общая информация

    Тип контента место хранения стиль управления
    Объекты инструментов(API, подключение к БД) Thread-Local (регион) У каждого есть копия, чтобы избежать сбоев.
    Информация о миссии(идентификатор, параметр) Очередь (глобальная) Используйте потокобезопасную передачу очереди.
    Результат расчета(статистика) Глобальный список/Dict (глобальный) Должно соответствоватьthreading.Lock。

    Проще говоря: **"Получите частные инструменты (соединения) самостоятельно и поместите общедоступную информацию (данные) в очередь (Очередь/Блокировка)".**

    фиксатор резьбы

    Основные понятия

    В многопоточной среде, когда несколько потоков пытаются одновременно изменить одну и ту же глобальную переменную или общий ресурс (например, файл, соединение с базой данных, глобальный список), возникает ошибка.Состояние гонки, что приводит к путанице данных.threading.LockЭто примитив синхронизации, который гарантирует, что только один поток может одновременно войти в защищенный блок кода.

    1. Стандартное использование

    Самый безопасный и рекомендуемый способ — сопоставитьwithИспользуйте повествовательные предложения. Это гарантирует, что даже если внутри блока возникнет исключение, блокировка будет снята правильно, чтобы избежать взаимоблокировки.

    импорт потоков

# 1. Создайте объект блокировки
my_lock = резьба.Lock()
общий_счетчик = 0

защита приращения_задачи():
    глобальный общий_счетчик
    # 2. Используйте with для автоматического управленияacquire() и Release().
    с my_lock:
        # Код в этом блоке может выполняться только одним потоком одновременно
        темп = общий_счетчик
        температура += 1
        общий_счетчик = температура

# Запускаем несколько тестов потоков
threads = [threading.Thread(target=increment_task) для _ в диапазоне (100)]
для t в потоках: t.start()
для t в потоках: t.join()

print(f"Окончательный счетчик: {shared_counter}")

    2. Ручной метод управления.

    Хотя это и не рекомендуется, иногда требуется более точный контроль. Вы должны вручную позвонитьacquire()получить замок иfinallyпозвонить в блокrelease()。

    блокировка = резьба.Lock()

защита manual_task():
    lock.acquire() #Получить блокировку. Если замок уже занят, он заблокируется (подождет) здесь.
    попробуйте:
        # Выполняем задачи
        пройти
    наконец:
        lock.release() # Должен быть освобожден, иначе другие потоки никогда не смогут выполниться

    3. Характеристики блокировки: неповторяемость.

    threading.LockЭто не реентерабельно. Это означает, что если тот же поток снова запросит ту же блокировку, когда он уже удерживает блокировку, он «заблокируется» сам (взаимная блокировка).

    4. Когда следует использовать Lock?

    Вопросы производительности

    Чрезмерное использование блокировок приведет к снижению производительности программы, поскольку несколько потоков попадут «в очередь на выполнение». Если возможно, отдайте приоритет использованиюqueue.Queueили то, что мы обсуждали ранееThread-Local Storage, эти методы обычно более эффективны и менее подвержены ошибкам, чем частая блокировка.

    Асинхронное программирование на Python

    В Python,async defиawaitреализованАсинхронное программированиеосновной синтаксис. Они не позволяют программе зависать во время ожидания задач ввода-вывода (таких как сетевые запросы, чтение файлов) и вместо этого могут выполнять другие задачи, значительно повышая производительность.

    1. async def: определить функцию сопрограммы

    Когда вы добавляете определение функции с помощьюasync, функция станетФункция сопрограммы. Когда вы его вызываете, он не выполняет содержимое немедленно, а возвращает «объект сопрограммы».

    асинхронная защита fetch_data():
    print("Начать получение данных...")
    # Моделирование трудоемких задач
    вернуть {"данные": "успех"}

# Прямой вызов получит только объект сопрограммы и не выполнит печать
результат = выборка_данных()
print(result) # Вывод: <coroutine object fetch_data at ...>

    2. ожидание: приостановить и подождать

    awaitможет быть толькоasync defДля внутреннего использования. Его функция — «временно приостановить текущую сопрограмму, дождаться завершения последующих задач и получить возвращаемое значение». Во время ожидания система может выполнять другие асинхронные задачи.

    импортировать асинхронный код

асинхронное определение main():
    # Используйте await для выполнения сопрограммы и получения результатов
    данные = ожидайте выборки_данных()
    print(f"Собрать результаты: {данные}")

# Запускаем запись для асинхронных программ
asyncio.run(main())

    3. Таблица сравнения ключей

    грамматика Описание функции На что следует обратить внимание
    async def Объявить асинхронную функцию Возвращается объект сопрограммы, а не результат выполнения.
    await Дождитесь завершения асинхронных задач Может быть написано только внутри асинхронных функций.
    asyncio.run() Запустить самую внешнюю асинхронную запись Программу обычно нужно вызвать только один раз.

    4. Распространенные ошибки и исправления

    5. Зачем использовать асинхронный режим?

    Представьте, что вы готовите:

    Завершите сопрограмму и верните результат

    loop.run_until_complete()даasyncioМетод нижнего уровня в модуле используется для выполнения сопрограммы до ее завершения и возврата результата. После Python 3.7, хотя официально рекомендуется использоватьasyncio.run(), но вам все равно придется использовать этот метод в некоторых конкретных ситуациях (например, когда вам нужно повторно использовать циклы событий или настроить логику запуска).

    1. Основной процесс использования

    использоватьrun_until_completeСначала необходимо получить или создать объект цикла событий, а затем передать ему сопрограмму.

    импортировать асинхронный код

асинхронная защита my_task():
    ожидайте asyncio.sleep(1)
    вернуть «Задача выполнена»

# 1. Получить цикл событий
цикл = asyncio.get_event_loop()

# 2. Выполнить сопрограмму до завершения и напрямую получить возвращаемое значение
результат = цикл.run_until_complete(my_task())

print(result) #Output: Задача завершена

    2. Отличия от asyncio.run()

    Оба могут получить возвращаемое значение, но управляют жизненным циклом по-разному:

    характеристика asyncio.run() (рекомендуется) loop.run_until_complete()
    степень автоматизации высокий. Автоматически создавайте, замыкайте циклы и очищайте задачи. Низкий. Жизненным циклом цикла необходимо управлять вручную.
    возможность повторного использования Низкий. Каждый вызов создает новый цикл. высокий. В одном цикле может выполняться несколько задач.
    Ограничения использования Невозможно использовать в уже работающем цикле. Более гибкий и часто используется в устаревшем коде или средах тестирования.

    3. Получите результаты в существующих циклах

    Если вы находитесь в уже запущенном скрипте и хотите убедиться, что сопрограмма выполнена и значение получено, вы можете использовать этот метод:

    импортировать асинхронный код

асинхронное определение add(a, b):
    вернуть а + б

цикл = asyncio.new_event_loop()
asyncio.set_event_loop(цикл)

попробуйте:
    # Выполняем первое задание
    val1 = цикл.run_until_complete(добавить(10, 20))
    #Выполняем второе задание
    val2 = цикл.run_until_complete(add(val1, 5))
    print(f"Окончательный результат: {val2}")
наконец:
    # Должно быть закрыто вручную
    цикл.закрыть()

    4. Получите результаты нескольких задач

    Если вы хотите, чтобы несколько сопрограмм выполнялись параллельно и равномерно получали возвращаемое значение, вам необходимо сопоставитьasyncio.gather：

    асинхронная задача определения (идентификатор):
    вернуть f"результат {id}"

цикл = asyncio.get_event_loop()
# сбор объединит несколько сопрограмм в одну задачу, а run_until_complete будет ждать завершения всех.
результаты = цикл.run_until_complete(asyncio.gather(задача(1), задача(2), задача(3)))
print(results) #Output: ['Результат 1', 'Результат 2', 'Результат 3']

    5. Общие меры предосторожности

    asyncio.run()Это API высокого уровня, представленный начиная с Python 3.7. Это наиболее рекомендуемый способ запуска асинхронных программ. оно автоматически позаботится об этомУстановите цикл событий, выполните сопрограмму и закройте цикл после завершения.. Самое главное, что оно будет передано непосредственно обратно в сопрограмму.returnценить.

    1. Основные методы сбора данных

    Вам просто нужноasync defВызов функции передаетсяasyncio.run(), она вернет результат как обычная синхронная функция.

    импортировать асинхронный код

асинхронная защита Calculate_score (имя):
    print(f"Подсчет очков {name}...")
    await asyncio.sleep(1) # Имитация трудоемких задач
    вернуть 95

# Получите результат возврата напрямую
Final_score = asyncio.run(calculate_score("Чжан Сяомин"))

print(f"Итоговый результат: {final_score}") # Вывод: 95

    2. Обработка результатов нескольких задач

    Обычно мы определяемmain()функционировать как точка входа и получать результаты всех подзадач внутри, и, наконец, с помощьюasyncio.run(main())Единый вывод.

    асинхронная защита Task_a():
    вернуть «яблоко»

асинхронная защита Task_b():
    вернуть «банан»

асинхронное определение main():
    # Используйте сбор в основном для одновременного выполнения
    результаты = ждут asyncio.gather(task_a(), Task_b())
    return results # Возвращаем список

# Получите возвращаемое значение main через asyncio.run
all_fruits = asyncio.run(main())
print(all_fruits) # Вывод: ['apple', 'banana']

    3. Правила выполнения asyncio.run()

    Элементы правил иллюстрировать
    единственный вход В продолжении выполнения обычно вызывается только один раз.asyncio.run()。
    Автоматическая очистка Он автоматически отменяет все оставшиеся задачи и закрывает пул потоков, что очень безопасно.
    Предел вложенности не могууже естьasync defвнутренний вызов функцииasyncio.run()。

    4. Распространенные ошибки: RuntimeError.

    Если вы находитесь внутри асинхронной функции и пытаетесь получить результаты другой асинхронной функции, используйтеawait, вместоasyncio.run()。

    # Демонстрация ошибки
асинхронная защита sub_task():
    вернуть 10

асинхронное определение main():
    # Здесь произойдет ошибка: RuntimeError: asyncio.run() нельзя вызвать из работающего цикла событий.
    res = asyncio.run(sub_task())
    
# Правильная коррекция
асинхронное определение main():
    res = await sub_task() # Пожалуйста, используйте await в асинхронной среде

    5. Практические рекомендации

    Анализ данных Python

    Научные операции Python NumPy

    NumPy(Numerical Python) — самая важная библиотека научных вычислений в Python. Он обеспечивает эффективные объекты многомерного массива.ndarrayи большую библиотеку математических функций для работы с этими массивами. Это основа науки о данных, машинного обучения (например, Pandas, Scikit-learn, TensorFlow) и других областей.

    1. Зачем выбирать NumPy вместо собственного списка?

    2. Основной объект: базовые операции ndarray.

    импортировать numpy как np

# Создаём одномерные и двумерные массивы
arr1 = np.array([1, 2, 3])
arr2 = np.array([[1, 2], [3, 4]])

# Быстро создать определенный массив
нули = np.zeros((3, 3)) # матрица 3x3 со всеми нулями
ones = np.ones((2, 4)) # матрица 2x4 со всеми единицами
глаз = np.eye(3) # единичная матрица 3x3
range_arr = np.arange(0, 10, 2) # [0, 2, 4, 6, 8]

    3. Часто используемые операции с массивами и атрибуты

    Функция Пример кода иллюстрировать
    Проверка формы arr.shape Возвращает размер каждого измерения (например, (3, 2)).
    изменить форму arr.reshape(1, 6) Изменение размеров без изменения данных.
    Умножение матрицы np.dot(a, b)илиa @ b Выполните умножение матриц в линейной алгебре.
    статистическая функция np.mean(), np.std() Рассчитайте среднее, стандартное отклонение, максимальное и минимальное значения.

    4. Нарезка и индексирование

    Синтаксис нарезки NumPy аналогичен синтаксису Python List, но более мощный и поддерживает одновременную многомерную нарезку:

    arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Получаем второй столбец (индекс 1)
print(arr[1, :]) # [4, 5, 6]

# Получаем подматрицу 2x2 в правом нижнем углу
print(arr[1:, 1:]) # [[5, 6], [8, 9]]

    5. Установка и проверка версии

    6. Используйте с Нумбой

    Как упоминалось ранее,NumbaОн может прекрасно распознавать структуру массива NumPy и далее компилировать сложные операции NumPy в машинный код, достигая предела выполнения, близкого к родному языку C.

    Python эффективно обрабатывает большие объемы данных Numba

    NumbaЭто JIT-компилятор с открытым исходным кодом, специально разработанный для ускорения кода Python, обрабатывающего большие объемы данных. Он может переводить функции Python в машинный код со скоростью выполнения, сравнимой со скоростью C, C++ или Fortran, и особенно подходит дляNumPyОперации с массивами.

    1. Основные функции и преимущества

    2. Основные примеры использования

    Самый простой способ использовать Numba — добавить@jitили@njitДекоратор.

    из numba import njit
импортировать numpy как np

# @njit представляет режим «nopython», который гарантирует отсутствие входа в парсер Python и является самым быстрым
@njit
защита fast_function(n):
    итого=0
    для я в диапазоне (n):
        всего += я
    общая сумма возврата

# Первый вызов скомпилируется, второй вызов напрямую выполнит машинный код
печать (fast_function (10000000))

    3. Сравнение шаблонов: nopython против объекта

    модель Декоратор иллюстрировать
    режим nopython @njit Рекомендуется.Полностью отделен от интерпретатора Python и напрямую компилируется в машинный код. Если код программы содержит части, которые не могут быть скомпилированы, будет сообщено об ошибке.
    объектный режим @jit Если его не удастся скомпилировать, он вернется к синтаксическому анализатору Python для выполнения. Улучшения производительности обычно ограничены.

    4. Часто используемые методы: параллельные операции.

    Чтобы воспользоваться преимуществами многоядерных возможностей вашего процессора, просто включитеparallel=Trueи использоватьprange。

    из numba import njit, prange

@njit(параллельно=Истина)
защитапараллельная_сумма(А):
    с = 0
    # prange автоматически распределит циклы по разным ядрам процессора
    для меня в prange(A.shape[0]):
        s += А[я]
    вернуть с

    5. Установка и проверка зависимостей.

    6. Ограничения использования

    Инструмент анализа данных Pandas

    Что такое панды?

    Pandas — это инструмент анализа и манипулирования данными на основе Python, предназначенный для обработки структурированных данных, таких как табличные данные или данные временных рядов.

    Основные структуры данных Pandas

    Основные особенности Панды

    Примеры использования

    импортировать панд как pd

# Создать фрейм данных
data = {'Имя': ['Алиса', 'Боб', 'Чарли'],
        «Возраст»: [25, 30, 35],
        «Город»: [»Тайбэй», «Тайчжун», «Гаосюн»]}
df = pd.DataFrame(данные)

# Просмотр данных
печать (дф)

# Фильтровать информацию старше 28 лет
filtered_df = df[df['age'] > 28]
печать (filtered_df)

    Применимые сценарии

    Почему стоит выбрать панд?

    Pandas предоставляет эффективные, гибкие и интуитивно понятные методы работы, которые особенно подходят для анализа и обработки данных. Это один из незаменимых инструментов в области науки о данных и машинного обучения.

    в заключение

    Pandas — мощный инструмент анализа данных, и как новички, так и опытные пользователи могут извлечь выгоду из его простого в использовании дизайна и обширных функций.

    Python Googletrans

    Установить Гуглтранс

    Сначала вам нужно установитьgoogletransнабор. Введите следующую команду в командной строке:

    pip install googletrans==4.0.0-rc1

    Примечание. Пожалуйста, подтвердите версию при установке.4.0.0-rc1, поскольку более старые версии могут больше не работать.

    Основные примеры использования

    Вот пример перевода с английского на традиционный китайский:

    из переводчика импорта Googletrans

#Инициализируем объект переводчика
переводчик = Переводчик()

# Перевести текст
text = "Привет, как дела?"
результат = переводчик.translate(text, src="en", dest="zh-tw")

# Вывод результатов перевода
print("исходный текст:", текст)
print("Перевод:", result.text)

    Поддерживаемые языковые коды

    Вы можете переводить на несколько языков, вот коды распространенных языков:

    На что следует обратить внимание

    Googletrans — это неофициальный API-интерфейс Google Translate, который может перестать работать из-за изменений со стороны Google. Если вы обнаружите, что функция перевода не работает, рассмотрите возможность использования других API перевода, например официального облачного перевода Google. API.

    Другие наборы для перевода Python

    DeepL Translator

    DeepL предоставляет услуги высокоточного перевода, но для использования API разработчика требуется ключ API.

    Microsoft Translator

    Инструмент перевода, предоставляемый Microsoft, поддерживает многоязычный перевод, но требует использования настроек ключа API Azure.

    Amazon Translate

    Служба перевода, предоставляемая Amazon Web Services (AWS), обеспечивает эффективный перевод многоязычных текстов, доступ к которой осуществляется через ключ API, предоставленный AWS.

    LibreTranslate

    LibreTranslate — это инструмент перевода с открытым исходным кодом, который может настроить собственный сервер и не требует ключа API. Некоторые сторонние публичные серверы также предлагают возможность использовать их без ключа API.

    TextBlob

    TextBlob — это инструмент для обработки естественного языка со встроенными функциями Google Translate. Однако более старые версии не требуют ключа API и, возможно, придется обратить внимание на поддержку версий.

    MyMemory

    MyMemory обеспечивает перевод на основе памяти. Для некоторых функций не требуется ключ API, но для расширенного использования может потребоваться приложение.

    в заключение

    Среди конкурентов Googletrans LibreTranslate и некоторые версии TextBlob предлагают варианты, не требующие ключа API. Если вам нужен инструмент, который совершенно бесплатен и не требует дополнительной настройки, рассмотрите эти варианты.

    OpenCC китайская конвертация

    OpenCC(Open Chinese Convert) — проект с открытым исходным кодом, посвященный преобразованию упрощенного китайского языка в традиционный китайский. Это не просто преобразование слов в слова, но, что более важно, оно обрабатываетуровень словарного запасаконверсия и различия в привычках использования слов в разных регионах (материковый Китай, Тайвань, Гонконг).

    1. Основные преимущества OpenCC