import sys

sys.exit()

См. также How do I terminate a script? site:stackoverflow.com.

На примере переменной окружения PATH:

import os

l = os.environ['PATH'].split(';')
for i in l:
   print(i)

Здесь os.environ['PATH'] это содержимое переменной окружения, где пути отделены друг от друга символом точки с запятой ';'. Метод split() генерирует список l по этому разделителю. Цикл for выведет содержимое списка.

Этот код на Windows 10 выведет что-нибудь наподобие:

C:\Users\John\.pyenv\pyenv-win\versions\3.13.1
C:\Users\John\.pyenv\pyenv-win\versions\3.13.1\Scripts
C:\Users\John\.pyenv\pyenv-win\versions\3.13.1\bin
C:\Users\John\AppData\Roaming\Python\Python313\Scripts
c:\Users\John\miniconda3\condabin
C:\WinAVR-20100110\bin
C:\WinAVR-20100110\utils\bin
C:\Windows\System32
C:\Windows
C:\Windows\System32\wbem
C:\Windows\System32\WindowsPowerShell\v1.0\
C:\Windows\System32\OpenSSH\
C:\Program Files\Docker\Docker\resources\bin
C:\Program Files (x86)\Common Files\Adobe\AGL
C:\Program Files (x86)\NVIDIA Corporation\PhysX\Common
C:\Program Files\NVIDIA Corporation\NVIDIA NvDLISR
C:\Program Files\PuTTY\
C:\Program Files\Git\cmd
C:\Program Files\dotnet\
C:\Program Files\Git LFS
C:\Users\John\AppData\Local\Programs\Python\Launcher\
C:\Users\John\.pyenv\pyenv-win\bin
C:\Users\John\AppData\Local\Microsoft\WindowsApps

См. также How can I access environment variables in Python? site:stackoverflow.com.

Для этого используйте объект filedialog из модуля tkinter. Например:

import tkinter as tk
from tkinter import filedialog

def open_file():
   # Создание корневого окна, но в скрытом режиме:
   root = tk.Tk()
   root.withdraw()

   # Открытие диалога выбора файла:
   file_path = filedialog.askopenfilename(
      title="Выберите файл",
      filetypes=[
         ("Текст", "*.txt"),
         ("Все файлы", "*.*")
      ]
   )
    
   if file_path:
      print(f"Выбран файл: {file_path}")
      return file_path
   return None

fi = open(open_file(), encoding='utf8')for line in fi:
   print(line)
fi.close()

Ctrl+D

Это так называемые f-строки, предназначенные форматирования вывода при печати с помощью функции print(). Значения выводимых переменных и вычисленных выражений подставляются в строку с помощью фигурных скобок. Это быстрый и удобочитаемый метод динамического форматирования печатаемых сообщений.

name = "Алиса"
age = 30
sentence = f"Меня зовут {name}, и мне {age} лет."
print(sentence)

Этот код выведет:

Меня зовут Алиса, и мне 30 лет.

С помощью f-строк легко реализовать вывод нужного количества значащих цифр после запятой при печати значений float. Например:

num = 3.14159
formatted = f"{num:.2f}"
print(formatted)  # этот код выведет: 3.14

Пример функции get_file_size, которая возвратит размер файла без его открытия:

from pathlib import Path

def get_file_size(file_path):
    try:
        return Path(file_path).stat().st_size
    except FileNotFoundError:
        print(f"Error: File '{file_path}' not found")
        return None
    except Exception as e:
        print(f"An error occurred: {e}")
        return None

Это можно сделать с помощью вот такого пользовательского класса WindowOutput:

class WindowOutput:
    def __init__(self, window):
        self.window = window
        self.window.scrollok(True)  # разрешает прокрутку окна
        self.line = 0
        self._text = ""

    def write(self, text):
        self._text += text
        if '\n' in text:
            lines = self._text.split('\n')
            for line in lines[:-1]: # обработка всех завершенных строк
                self.window.addstr(line + '\n')
                self.window.refresh()
            self._text = lines[-1]  # сохраняет любые оставшиеся строки

    def flush(self):
        if self._text:
            self.window.addstr(self._text)
            self.window.refresh()
            self._text = ""

Предположим, что у вас есть два окна curses без бордюра. Первое окно сверху, в переменной w1, высотой в одну строку, второе окно ниже, занимающее все остальное пространство экрана, в переменной w2. И нам надо, чтобы функция print выводила сообщения в нижнее окно w2.

Вспомогательные функции:

# Функция определяет общий размер экрана консоли в символах:
def get_screen_size():
    try:
        # Инициализация библиотеки curses:
        screen = curses.initscr()
        # Получение высоты и ширины экрана:
        height, width = screen.getmaxyx()
        # Очистка curses:
        curses.endwin()
        
        return height, width

    except Exception as e:
        print(f"Error getting screen size: {e}")
        return None, None

# Функция создает окно curses заданного размера,
# с определенным положением на экране консоли:
def create_window(height=None, width=None, y=0, x=0, has_border=True):
    try:
        # Initialize curses
        screen = curses.initscr()
        curses.start_color()
        curses.noecho()
        curses.cbreak()
        screen.keypad(True)

        # Если размеры окна не указаны, то используется экран целиком:
        if height is None or width is None:
            max_height, max_width = screen.getmaxyx()
            height = height or max_height
            width = width or max_width

        # Создание окна:
        window = curses.newwin(height, width, y, x)
        if has_border:
            window.box()
        window.refresh()

        return screen, window

    except Exception as e:
        curses.endwin()
        print(f"Error creating window: {e}")
        return None, None

# Функция очистки:
def cleanup_curses(screen):
    if screen:
        screen.keypad(False)
        curses.nocbreak()
        curses.echo()
        curses.endwin()

Пример функции, которая создает окна w1, w2 и настраивает вывод функции print в окно w2:

def init_interface():
    height, width = get_screen_size()

    w1h = 1             # высота окна w1
    global s1, w1
    s1, w1 = create_window(w1h, width, 0, 0, has_border=False)
    w2h = height - w1h  # высота окна w2
    global s2, w2
    s2, w2 = create_window(w2h, width, w1h, 0, has_border=False)
    global original_stdout
    # Сохранение оригинального вывода консоли
    # для последующего восстановления:
    original_stdout = sys.stdout
    sys.stdout = WindowOutput(w2)

Эта функция возвращает вывод функции print в оригинальное состояние:

def revert_interface():
    sys.stdout = original_stdout
    cleanup_curses(s1)
    cleanup_curses(s2)

Как это работает:

if __name__ == "__main__":
    # Здесь print печатает как обычно:
    print("Обычная печать")

    myw.init_interface()
    # Теперь print выводит сообщения в окно w2:
    print("Вывод сообщений перенаправлен")

    myw.revert_interface()
    print("Печать возвращена обратно в stdout")

Пример функции, которая возвратит текст содержимого окна:

def get_window_content(window):
    try:
        height, width = window.getmaxyx()
        content = []
        for y in range(height):
            # Извлечение содержимого строки, перекодирование из байт в строку:
            line = window.instr(y, 0, width).decode('utf-8')
            # Удаление null-символов и завершающих пробелов:
            line = line.replace('\x00', '').rstrip()
            if line:  # Добавление только непустых строк:
                content.append(line)
        return '\n'.join(content)

    except Exception as e:
        return f"Error getting window content: {e}"

В перехвате нажатий без блокировки поможет модуль msvcrt.

import msvcrt

# Не блокирующая проверка нажатой клавиши. Если была нажата клавиша,
# то функция возвратит её символьное представление.
def check_keyboard():
    if msvcrt.kbhit():  # вернет true, если было нажатие
        key = msvcrt.getch().decode('utf-8', errors='ignore').lower()
        return key
    return None

Ниже показан пример использования функции check_keyboard. Этот блок кода может быть вставлен в основной цикл программы:

                while True:
                    # Тут какие-то действия
                    ...
                    key = check_keyboard() # проверка нажатия без блокировки
                    if key == 'q':         # выход, если 'q'
                        print("\nComparison cancelled by user")
                        return
                    elif key == 'p':       # пауза, если 'p'
                        print("\nPaused. Press any key to continue...")
                        msvcrt.getch()     # ождание клавиши с блокировкой
                        print("\nContinuing comparison...")
                    else:
                        pbar.update(1)
                    ...

Ошибка произошла из-за того, что вместо библиотеки pyserial была установлена библиотека serial. Чтобы устранить ошибку, нужно удалить библиотеку serial и установить библиотеку pyserial:

$ pip uninstall serial
$ pip install pyserial

import logging

CRSF_BAUDRATE = 420000
ser = serial.Serial("/dev/ttyUSB1", CRSF_BAUDRATE)
logger = logging.getLogger(__name__)

logging.basicConfig(format='%(asctime)s.%(msecs)03d %(message)s',
                    datefmt='%y%m%d %H:%M:%S',
                    filename='log.txt',
                    encoding='utf-8', level=logging.INFO)

logger.debug('debug')
logger.info('info')
logger.warning('warning')
logger.error('error')

Этот код выведет в файл log.txt:

250319 13:05:02.282 info
250319 13:05:02.282 warning
250319 13:05:02.282 error

[Альтернативное решение: вывод в файл]

Модуль logging выводит текст, представленный в кодировке UTF-8. Но иногда необходимо вывести в лог текст в произвольной кодировке. Для такого случая можно использовать вывод в двоичный файл и формирование строки с датой и временем вручную, с помощью модуля datetime.

Ниже показан пример модуля log.py, где для вывода в лог произвольного текста реализована функция raw, а для вывода текста в кодировке UTF-8 реализована функция umsg.

from datetime import datetime

logfilename = None

def get_current_time():
    return datetime.now().strftime("%y%m%d %H:%M:%S")

def init_log(logfile):
    global logfilename
    logfilename = logfile

def umsg(msg):
    file = open(logfilename, "ab") 
    file.write(bytearray(get_current_time(), encoding="utf-8"))
    file.write(bytearray([0x20]))
    file.write(bytearray(msg, encoding="utf-8"))
    file.write(bytearray('\n', encoding="utf-8"))

def raw(msg):
    file = open(logfilename, "ab") 
    file.write(bytearray(get_current_time(), encoding="utf-8"))
    file.write(bytearray([0x20]))
    file.write(msg)
    file.write(bytearray('\n', encoding="utf-8")) 

Пояснение:

datetime.now() — возвращает текущую дату и время.

strftime("%y%m%d %H:%M:%S") — преобразует дату и время в строку согласно указанному формату:

%y — год без века (две цифры, например, 23 для 2023 года).
%m — месяц (две цифры, 01–12).
%d — день месяца (две цифры, 01–31).
%H — час в 24-часовом формате (00–23).
%M — минуты (00–59).
%S — секунды (00–59).

Пример вывода:

230601 14:30:45

Если вам нужно получить дату и время для конкретного момента (не текущего), можно создать объект datetime вручную и отформатировать его аналогично. Например:

from datetime import datetime

custom_date = datetime(2023, 6, 1, 14, 30, 45)
formatted_date = custom_date.strftime("%y%m%d %H:%M:%S")

print(formatted_date)  # Вывод: 230601 14:30:45

import traceback
...

if __name__ == "__main__":
   parse_command_line()
   # Проверка, если не было предоставлено аргументов,
   # то вывод подксказки по командной строке и выход:
   if not any(vars(args).values()):
       parser.print_help()
       exit(1)

   try:
      # Тут код программы, проверяемой на возникновение ошибки:
      ...
      
   except SystemExit:
       pass
   except Exception as e:
      # Печать полной информации об ошибке: номер строки кода, где
      # возникла ошибка, стек вызовов, сообщение об ошибке:
      print(f"Error: {str(e)}\n{traceback.format_exc()}")
      # Просто вывод сообщения об ошибке:
      #print(f"Error: {str(e)}")
      revert_interface()
   finally:
      try:
         revert_interface()
      except:
         pass

Специальная переменная __name__ позволяет получить имя текущего модуля, но это не совсем то, что нужно:

def some_function():
    print(__name__)  # печать имени модуля (не функции)

А как получить имя текущей функции в целях отладки, по аналогии как на C мы используем gcc-макрос __FUNCTION__?

На Python для этого есть 2 метода:

Метод 1. С помощью модуля inspect:

import inspect

def some_function():
    current_function_name = inspect.currentframe().f_code.co_name
    print(current_function_name)  # Напечатает: some_function

Метод 2. С помощью sys._getframe():

import sys

def some_function():
    current_function_name = sys._getframe().f_code.co_name
    print(current_function_name)  # Напечатает: some_function

Чаще всего используется и рекомендуется первый метод, на основе inspect.currentframe().f_code.co_name.

"Pickling" это процесс, посредством которого иерархия объектов Python преобразуется в поток байт, а "unpickling" это обратный процесс, где байтовый поток (из двоичного файла или байтового объекта) преобразуется обратно в иерархию объектов. Pickling (и unpickling) альтернативно известен как "сериализация", "маршаллинг" [1] или "выравнивание" (flattening); однако для во избежание путаницы в контексте Python используются термины "pickling" и "unpickling".

import time

current_ms = time.time_ns() // 1_000_000

import argparse, sys

parser = None
args = None

def parse_arguments():
    parser = argparse.ArgumentParser(
        description='Моя крутая программа Python',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog='''
Examples:
  serial_reader.py -a 1      # пример использования опции -a
  serial_reader.py -b 50     # пример использования опции -b
  serial_reader.py -c 4      # пример использования опции -c
        '''
    )
    parser.add_argument('-a', '--afull', type=int,
                       help='Описание опции -a (default 1)', default=1)
    parser.add_argument('-b', '--bfull', type=int,
                       help='Описание опции -b (default 10)', default=10)
    parser.add_argument('-c', '--cfull', type=int,
                       help='Описание опции -c (default 8)', default=8)
    args = parser.parse_args()
    if len(sys.argv) == 1:
        parser.print_help()
        sys.exit(1)
    return args

def main():
    global args, parser
    args = parse_arguments()
    ...

if __name__ == "__main__":
    main()

Следующий код проверялся на чипе FT232R, но вероятно будет работать и на любом чипе для виртуального последовательного порта USB:

from serial import Serial

def init_serial():
    comport = Serial(port='COM1',  baudrate=115200, timeout=0.1, rtscts=False, dsrdtr=False)
    comport.rts = 0    # установит в лог. 1 физический уровень сигнала RTS
    comport.dtr = 0    # установит в лог. 1 физический уровень сигнала DTR
    return comport

Ножками RTS и DTR на отладочной плате осуществлялось управление сбросом и активацией режима программирования микроконтроллера. Поэтому для сохранения связи с программой микроконтроллера понадобилось устанавливать сигналы RTS и DTR в неактивное состояние.

Обратите внимание, что эти сигналы имеют логическую инверсию уровня. Т. е. для того, чтобы установить их в лог. 1 (неактивный уровень), необходимо записать 0 в соответствующее свойство объекта serial, и наоборот.