В данном руководстве собраны практические примеры использования Python (набор кода и выполнение) непосредственно в редакторе nonepad++. Все примеры разбиты по категориям и содержат реальные результаты вычислений, включая обработку ошибок и побитовые операции.
- Операторы печати
- Операторы if и def
- Импорты и системные модули
- Лямбда-функции (Создание собственных формул)
- Списки (Изменяемые массивы данных)
- Кортежи (Неизменяемые последовательности)
- Словари (Структуры ключ-значение)
- Множества (Работа с уникальными элементами)
- Строки (Текстовые операции)
- f-строки и форматирование (Красивый вывод и таблицы)
- Замыкания и фабрики функций (Продвинутые Lambda)
- Сложные структуры и конвейеры данных
- Списковые включения (Трансформация и Фильтрация)
- Функциональные методы: map и filter
- Работа с несколькими списками одновременно (zip)
- Агрегация данных (Свертка через reduce)
- Логические проверки массивов (all и any)
- Работа с числами и продвинутая математика
- Безопасная работа с None и опциональными значениями
- Конвейеры обработки данных (Chain of Operations)
- Работа с битами и флагами (Системное программирование)
_beg_
# По умолчанию выводится 5 символов после точки
x = 1.12344321
x ? 1.123443
# Изменяем число символов по умолчанию
_digits_ = 8
x ? 1.12344321
# Независимо от установок по умолчанию выводим нужное число символов
x ?.2 1.12
x ?.3 1.123
# Выводим целое число в hex-формате
a = 12345678
a ?h 0xbc614e
# Выводим целое число в bin-формате
a ?b 0b101111000110000101001110
_end_При использовании out() данные в процессе выполнения кода накапливаются в буфере и распечатываются сразу после ключевого маркера end. При этом распечатанные ранее данные будут удалены из этой области (если они там были).
_beg_
voltage = 220.5
current = 15
# 1. Форматирование текста и переменных в единой строке для одной колонки
out("Напряжение: {} В".format(voltage))
# 2. Использование спецификаторов формата (например, .1f) внутри строки
out("Мощность: {:.1f} Вт".format(voltage * current))
# 3. Передача нескольких строк для заполнения разных колонок
out("U = {} V".format(voltage), "I = {} A".format(current))
_end_
# > Напряжение: 220.5 В
# > Мощность: 3307.5 Вт
# > U = 220.5 V I = 15 A_beg_
out(" ДАТЧИК | СТАТУС | ЗНАЧЕНИЕ | ЕД.ИЗМ")
out("-" * 45)
row("Температура", "OK", 85.5, "°C")
row("Давление", "ALARM", 12.4, "Бар")
row("Расход", "OK", 1040, "м3/ч")
_end_
# > ДАТЧИК | СТАТУС | ЗНАЧЕНИЕ | ЕД.ИЗМ
# > ---------------------------------------------
# > ТемператураOK 85.5 °C
# > ДавлениеALARM 12.4 Бар
# > Расход OK 1040 м3/ч
_beg_
# Задаем ширину столбцов: 20 для имени, 10 для кода, 15 для статуса
w_cols = [20, 10, 15]
row("НАИМЕНОВАНИЕ", "КОД", "СТАТУС", w=w_cols)
row("-" * 40)
row("Главный двигатель", "M-01", "В работе", w=w_cols)
row("Насос охлаждения", "P-12", "Резерв", w=w_cols)
row("Вентилятор", "V-05", "Ремонт", w=w_cols)
_end_
# > НАИМЕНОВАНИЕКОД СТАТУС
# > ----------------------------------------
# > Главный двигательM-01 В работе
# > Насос охлажденияP-12 Резерв
# > ВентиляторV-05 Ремонт
_beg_
voltage = 220
current = 5.5
power = voltage * current
# Передача текстовых литералов и вычисленных
# переменных с явным указанием ширины колонок
row("Voltage (V):", voltage, "Current (A):", current, "Power (W):", power, w=[13, 5, 13, 5, 11, 5])
_end_
# > Voltage (V): 220 Current (A): 5.5 Power (W): 1210.0Разрешены только однострочные операторы. В ряде случаев этого вполне достаточно для быстрого использования if и def.
_beg_
x = 1
y = 0
# В многострочном виде операторы не работают. Код выполняется строго по одной строке
if(x > 2): !! ERROR: expected an indented block after 'if' statement on line 1 (<string>, line 1)
y = 10
def func(x, y): !! ERROR: expected an indented block after function definition on line 1 (<string>, line 1)
return x+y !! ERROR: 'return' outside function (<string>, line 1)
z = func(x,y) ? !! ERROR: name 'func' is not defined
# А в одну строку — работают отлично:
if(x < 2): y = 15
def func(x, y): return x+y
z = func(x,y) ? 16
_end_По умолчанию калькулятор содержит всю базовую математику. Если этого мало, можно «на лету» подключать стандартные библиотеки Python (если они установлены).
_beg_
# 1. Проверка версии Python, на которой работает калькулятор
import sys
sys.version ? 2.7.18 (v2.7.18:8d21aa21f2, Apr 20 2020, 13:25:05) [MSC v.1500 64 bit (AMD64)]
# 2. Модуль для работы с датой и временем
import datetime
current_year = datetime.date.today().year ? 2026
# 4. Генератор случайных чисел
import random
lucky_number = random.randint(1, 100) ? 42
_end_Поскольку калькулятор ориентирован на компактный код, стандартное многострочное определение функций через def часто неудобно. Вместо этого используются однострочные lambda функции.
_beg_
# 1. Простое определение и многократный вызов
hypot = lambda a, b: sqrt(a**2 + b**2)
res1 = hypot(3, 4) ? 5
res2 = hypot(10, 10) ?.2 14.14
# 2. Лямбда с условием (Тернарный оператор)
check = lambda v: "Overload" if v > 100 else "OK"
check(120) ? Overload
# 3. Применение функции ко всему списку (через map)
data = [1, 2, 3, 4, 5]
processed = list(map(lambda x: x * 10, data)) ? [10, 20, 30, 40, 50]
# 4. Сортировка сложных данных по ключу (например, по значению датчика)
sensors = [(1, 25.5), (2, 18.0), (3, 30.2)]
sorted_sensors = sorted(sensors, key=lambda x: x[1]) ? [(2, 18.0), (1, 25.5), (3, 30.2)]
_end_Списки — это динамические массивы. Главное правило в SmartCalc: методы, которые мутируют (изменяют) список на месте (например, append), возвращают None. Чтобы сразу увидеть обновленный результат вычислений, используйте логическую конструкцию or имя_списка.
_beg_
# 1. Инициализация и безопасное добавление элементов на лету
list1 = [10, 20, 1000]
list1.append(40) or list1 ? [10, 20, 1000, 40]
# 2. Сложение (Конкатенация) списков
list_a = [1, 2, 3]
list_b = [10, 20, 30]
list_c = list_a + list_b ? [1, 2, 3, 10, 20, 30]
# 3. Генераторы списков (Быстрая фильтрация и математика в одну строку)
base_values = [1, 2, 3, 4, 5]
squares = [x**2 for x in base_values if x > 2] ? [9, 16, 25]
# 4. Срезы (Slicing) — извлечение любых частей массива
data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
first_three = data[:3] ? [0, 1, 2]
last_two = data[-2:] ? [8, 9]
every_second = data[::2] ? [0, 2, 4, 6, 8]
reversed_list = data[::-1] ? [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
# 5. Распаковка массивов (Unpacking) — только для Python 2
source = [100, 200, 300, 400, 500]
# В Python 2 нет расширенной распаковки (*middle), используем срезы
head = source[0]
middle = source[1:-1]
tail = source[-1]
head ? 100
middle ? [200, 300, 400]
_end_Кортежи похожи на списки, но их элементы нельзя изменить после создания. Это защищает конфигурационные данные от случайной перезаписи и позволяет использовать кортежи в качестве ключей для словарей.
_beg_
# 1. Определение кортежей (запятая обязательна, если элемент один)
t1 = (10, 20, 30, 40)
t2 = (100,)
# 2. Попытка изменения вызывает ошибку (Защита стабильности данных)
t1[0] = 99 !! ERROR: 'tuple' object does not support item assignment
# 3. Распаковка и быстрый атомарный обмен значениями переменных
a, b = 1, 2
a, b = b, a
a ? 2
# 4. Использование кортежа (например, координат) как ключа в словаре
locations = {(55.75, 37.61): "Moscow", (40.71, -74.00): "New York"}
locations[(40.71, -74.00)] ? New York
_end_Словари хранят данные в формате пар "Ключ: Значение". Идеально подходят для хранения настроек, конфигураций систем или табличных параметров.
_beg_
# 1. Определение словаря
map1 = {'sensor_1': 22.5, 'sensor_2': 24.0}
# 2. Безопасное добавление/изменение через update и конструкцию 'or'
map1.update({'sensor_3': 25.0}) or map1 ? {'sensor_3': 25.0, 'sensor_2': 24.0, 'sensor_1': 22.5}
# 3. Удаление элемента с извлечением его значения
deleted_val = map1.pop('sensor_1') ? 22.500000
# 4. Объединение двух словарей (Python 2 совместимый способ)
d_left = {'a': 1, 'b': 2}
d_right = {'b': 10, 'c': 3}
# В Python 2 нет оператора | для словарей, используем update с копией
merged = d_left.copy()
merged.update(d_right)
merged ? {'a': 1, 'c': 3, 'b': 10}
# 5. Агрегация данных по значениям
telemetry = {'temp': 36.6, 'volt': 12.1, 'amp': 1.5}
total_sum = sum(telemetry.values()) ? 50.200000
# 6. Безопасное чтение ключа (если ключа нет в словаре, вернет 0)
val = telemetry['speed'] if 'speed' in telemetry else 0 ? 0
_end_Множества хранят только уникальные элементы. Незаменимы для быстрой фильтрации дубликатов и выполнения теоретико-множественных операций.
_beg_
# 1. Быстрое удаление дубликатов из сырого списка данных
raw_data = [10, 20, 10, 30, 20, 40]
unique_data = set(raw_data) ? set([40, 10, 20, 30])
# 2. Математические операции с множествами
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
# Объединение (все уникальные элементы из обоих множеств)
a | b ? set([1, 2, 3, 4, 5, 6])
# Пересечение (только общие элементы)
a & b ? set([3, 4])
# Разность (элементы, которые есть в 'a', но отсутствуют в 'b')
a - b ? set([1, 2])
_end_Базовые операции с текстовыми данными: парсинг, поиск подстрок и замена.
_beg_
# 1. Разделение строки по разделителю и обратная сборка (Split & Join)
csv_data = "sensor_1,22.5,active"
parts = csv_data.split(",") ? ['sensor_1', '22.5', 'active']
joined = ";".join(parts) ? sensor_1;22.5;active
# 2. Поиск и замена подстроки
text = "python script"
has_py = "python" in text ? True
new_text = text.replace("python", "smart") ? smart script
# 3. Преобразование типов данных (из строки в число для расчетов)
val_num = float("15.5") * 2 ? 31
_end_Самый мощный и гибкий инструмент для красивого и понятного вывода результатов расчетов.
_beg_
# 1. Вставка вычислений прямо внутрь строки с округлением (.2f)
radius = 10
info = "Площадь: {:.2f} см2".format(pi * radius**2)
# 2. Вывод одного числа в разных системах счисления (Dec, Hex, Bin)
val = 255
bases = "Dec: {}, Hex: 0x{:02X}, Bin: 0b{:08b}".format(val, val, val)
# 3. Выравнивание строк для создания ровных столбцов таблиц
# :<10 (по левому краю), :>10 (по правому краю), :^10 (по центру)
v1, v2 = 10.5, 100.25
line1 = "Параметр А: {:>10}".format(v1)
line2 = "Параметр B: {:>10}".format(v2)
# 4. ОШИБКА: Использование \n в обычной переменной (Как делать НЕ НАДО)
# Калькулятор читает код строго построчно. Символ переноса строки \n ломает парсер.
bad_line = "Статус: OK\nВерсия: 1.0"
bad_line ? Статус: OK
Версия: 1.0 !! ERROR: invalid syntax (<string>, line 1)
Версия: 1.0 !! ERROR: invalid syntax (<string>, line 1)
_end_Замыкание — это конструкция, в которой функция возвращает другую функцию, при этом «запоминая» переменные из своего внешнего окружения. В SmartCalc это идеальный способ создавать специализированные инженерные инструменты в одну строку.
_beg_
# 1. Фабрика допусков (Контроль качества деталей)
# Внешняя функция принимает допустимую погрешность (tol) и возвращает НОВУЮ функцию,
# которая будет сверять реальные значения с целевыми.
make_checker = lambda tol: lambda val, target: abs(val - target) <= tol
# Создаем двух индивидуально настроенных "инспекторов"
check_strict = make_checker(0.01)
check_loose = make_checker(0.5)
# Проверяем детали (целевой номинальный размер — 100)
part_1 = check_strict(100.005, 100) ? True
part_2 = check_strict(100.2, 100) ? False
part_3 = check_loose(100.2, 100) ? True
# 2. Фабрика конвертеров величин
# Запоминаем коэффициент перевода физической величины внутри функции
create_converter = lambda factor: lambda value: value * factor
# Генерируем готовые функции перевода единиц
inch_to_mm = create_converter(25.4)
lb_to_kg = create_converter(0.453592)
res_mm = inch_to_mm(5) ? 127
res_kg = lb_to_kg(150) ?.2 68.04
_end_Здесь показано, как объединить списки, словари и генераторы для решения реальных задач одной-двумя строками кода, заменяя громоздкие многострочные циклы for.
_beg_
# 1. Векторная математика без привлечения тяжелых сторонних библиотек
v1 = [1, 2, 3]
v2 = [4, 5, 6]
# Скалярное произведение: последовательно перемножаем пары
# элементов (zip) и суммируем результат
dot_product = sum(x * y for x, y in zip(v1, v2)) ? 32
# 2. Паттерн "Командный диспетчер" (Словарь + Lambdas)
# Избегаем ступеней условий if/elif/else. Ключ словаря — команда,
# значение — выполняемая функция.
dispatcher = {'+': lambda a,b: a+b, '-': lambda a,b: a-b, 'pow': lambda a,b: a**b}
# Вызываем нужную математическую операцию динамически по текстовому имени
op = 'pow'
result = dispatcher[op](2, 8) ? 256
# 3. Сложный парсинг логов (Строки -> Списки -> Фильтрация -> Словарь)
# Дано: сырая текстовая строка с датчиков. Некоторые датчики выдают ошибку сбоя 'err'.
raw_log = "T1:22.5; T2:err; T3:24.1; T4:19.8"
# Шаг А: Разбиваем строку на пары ['Имя', 'Значение'],
# удаляя лишние пробелы через strip()
pairs = [item.strip().split(':') for item in raw_log.split(';')]
# Шаг Б: Собираем чистый словарь, отфильтровывая 'err', и сразу
# конвертируем данные во float
clean_data = {k: float(v) for k, v in pairs if v != 'err'}
clean_data ? {'T4': 19.8, 'T3': 24.1, 'T1': 22.5}
# Шаг В: Вычисляем среднее значение только по реально работающим датчикам
avg_temp = sum(clean_data.values()) / len(clean_data) ?.2 22.13
_end_Самый наглядный и лаконичный способ преобразования массивов, заменяющий цикл for с вложенным условием if.
_beg_
# Дано: Измеренные напряжения в сети (включая помехи и нулевые значения)
v_raw = [210, 220, 15, 235, 0, 190]
# 1. Простое линейное преобразование (Смещение всех элементов массива на +10)
v_plus_10 = [v + 10 for v in v_raw] ? [220, 230, 25, 245, 10, 200]
# 2. Фильтрация данных (Убираем импульсный "шум" и просадки линии ниже 100V)
v_clean = [v for v in v_raw if v > 100] ? [210, 220, 235, 190]
# 3. Комбинированный пример (Вычисление квадратов только для четных чисел)
squares = [x**2 for x in range(10) if x % 2 == 0] ? [0, 4, 16, 36, 64]
_end_Эти встроенные функции работают со структурами данных напрямую и часто оказываются эффективнее списковых включений на больших объемах информации.
_beg_
data = ["10.5", "20.1", "err", "30.5"]
# 1. map(): Применяем функцию float к каждому элементу последовательности строк
# (Конструкция list() необходима, чтобы развернуть
# итератор в видимый текстовый список)
numbers = list(map(float, ["1.1", "2.2", "3.3"])) ? [1.1, 2.2, 3.3]
# 2. filter(): Извлекаем и оставляем только те элементы, которые не равны 'err'
cleaned = list(filter(lambda x: x != "err", data)) ? ['10.5', '20.1', '30.5']
# 3. Цепочка (Pipeline): Сначала фильтруем ошибки, затем результат сразу
# переводим в числа
final = list(map(float, filter(lambda x: x != "err", data))) ? [10.5, 20.1, 30.5]
_end_Полностью заменяет классические громоздкие циклы с обращением по индексу вида for i in range(len(a)): ... a[i] + b[i].
_beg_
# Координатные массивы X и Y
xs = [1, 2, 3]
ys = [10, 20, 30]
# 1. Сшиваем два независимых списка в пары кортежей (x, y)
points = list(zip(xs, ys)) ? [(1, 10), (2, 20), (3, 30)]
# 2. Расчет расстояний (гипотенуз) для всех координатных пар одновременно
distances = [round((x**2 + y**2)**0.5, 2) for x, y in zip(xs, ys)] ? [10.05, 20.1, 30.15]
_end_Используется, когда необходимо последовательно применить операцию к элементам массива и «свернуть» весь список в одно единственное итоговое значение.
_beg_
from functools import reduce
vals = [10, 2, 5]
# 1. Находим произведение всех элементов массива между собой (10 * 2 * 5)
total_mult = reduce(lambda a, b: a * b, vals) ? 100
# 2. Сложная логика агрегации: Поиск самого длинного текстового слова в списке
words = ["Pump", "Generator", "Valve"]
longest = reduce(lambda a, b: a if len(a) > len(b) else b, words) ? Generator
_end_Функции анализируют массивы флагов или условий и возвращают одно булево значение (True или False). Они незаменимы для построения систем контроля допусков и блокировок (Stability Checks), полностью заменяя циклы с флагами типа found = False.
_beg_
tolerances = [0.01, 0.02, 0.05, 0.01]
# 1. all(): Проверяем, что абсолютно ВСЕ текущие допуски
# находятся ниже критического порога 0.03
is_safe = all(t < 0.03 for t in tolerances) ? False
# 2. any(): Проверяем, зафиксирован ли ХОТЯ БЫ ОДИН критический
# сбой в массиве параметров (значение > 1.0)
shocks = [0.1, 0.2, 1.5, 0.1]
critical = any(s > 1.0 for s in shocks) ? True
_end__beg_
# 1. Комплексные числа (Полезно для расчета электрических цепей и фазовых сдвигов)
z1 = 3 + 4j
z2 = 1 - 2j
z_sum = z1 + z2 ? (4+2j)
z_magnitude = abs(z1) ? 5
z_phase = __import__('cmath').phase(z1) ?.4 0.9273
# 2. Округление и точность (Пример реализации банковского округления ROUND_HALF_EVEN)
from decimal import Decimal, ROUND_HALF_EVEN
value = 2.675
rounded_bank = float(Decimal(str(value)).quantize(Decimal('0.01'), rounding=ROUND_HALF_EVEN)) ? 2.680000
rounded_std = round(value, 2) ? 2.670000
# 3. Статистические характеристики массива (Прямой расчет
# базовых формул без импорта модуля statistics)
data = [12, 15, 18, 21, 24]
n = len(data)
mean_val = sum(data) / n ? 18
variance = sum((x - mean_val) ** 2 for x in data) / (n - 1) ?.1 22
std_dev = variance ** 0.5 ?.2 4.69
_end__beg_
# 1. Реализация паттерна Elvis-оператора (Присвоение жесткого
# значения по умолчанию, если переменная пуста)
config_value = None
safe_val = config_value or "default" ? default
# 2. Цепочка безопасного доступа к глубоко вложенным словарям
# через тернарный оператор
nested_dict = {"a": {"b": {"c": 42}}}
deep_val = nested_dict.get("a", {}).get("b", {}).get("c") if nested_dict else None
missing_val = nested_dict.get("x", {}).get("y", {}).get("z") if nested_dict else None
# 3. Валидация входных данных с защитой от пустых значений типа
# None и несоответствия типов
process = lambda x: round(x ** 2, 2) if x is not None and isinstance(x, (int, float)) else 0
result1 = process(5.5) ? 30.250000
result2 = process(None) ? 0
_end__beg_
# 1. Цепочка преобразований входных параметров без выделения
# памяти под промежуточные переменные
raw = " temp=25.6;humid=65;press=1013 "
cleaned = dict(item.split('=') for item in raw.strip().split(';'))
temp_celsius = float(cleaned.get('temp', 0)) ? 25.600000
temp_fahrenheit = round(temp_celsius * 9/5 + 32, 1) ? 78.100000
# 2. Реализация паттерна "Pipeline" (Последовательный конвейер
# функций) с помощью reduce
from functools import reduce
pipeline = lambda val, funcs: reduce(lambda acc, f: f(acc), funcs, val)
funcs_list = [lambda x: x * 2, lambda x: x + 10, lambda x: x ** 0.5]
final_val = pipeline(5, funcs_list) ?.2 4.47
# 3. Логирование промежуточных состояний конвейера в процессе расчета через out()
data_flow = [1, 2, 3, 4, 5]
step1 = [x * 2 for x in data_flow]
out("Удвоили:", step1)
step2 = [x - 3 for x in step1]
out("Вычли 3:", step2)
step3 = [x for x in step2 if x > 0]
out("Положительные:", step3)
_end_
# > Удвоили: [2, 4, 6, 8, 10]
# > Вычли 3: [-1, 1, 3, 5, 7]
# > Положительные: [1, 3, 5, 7]Незаменимый раздел для низкоуровневых тестов, эмбеддеров и инженеров автоматизации (ПЛК/HMI/SCADA) при ручной распаковке регистров связи.
_beg_
# 1. Упаковка индивидуальных флагов в единую битовую маску
flags = {'read': 1, 'write': 2, 'execute': 4}
permissions = flags['read'] | flags['write'] # 1 | 2 = 3
has_read = bool(permissions & flags['read']) ? True
has_execute = bool(permissions & flags['execute']) ? False
# 2. Побитовое извлечение значений отдельных полей (Маскирование и Сдвиги)
status_register = 0b10110110
low_nibble = status_register & 0x0F ?b 0b110
high_nibble = (status_register >> 4) & 0x0F ?b 0b1011
bit3 = (status_register >> 3) & 1 ?b 0b0
# 3. Динамическая установка, сброс и инверсия (Toggle) выбранных битов в регистре
set_bit = lambda reg, pos: reg | (1 << pos)
clear_bit = lambda reg, pos: reg & ~(1 << pos)
toggle_bit = lambda reg, pos: reg ^ (1 << pos)
reg = 0b0101
reg = set_bit(reg, 2) ?b 0b101
reg = clear_bit(reg, 0) ?b 0b100
_end_