Как я мог заставить его остановиться через некоторое время, даже если код все еще запущен? Пожалуйста, помогите мне разобраться.
Лучший ответ:
Я бы использовал модуль multiprocessing , который генерирует новые процессы (а не потоки) для распараллеливания задач.
Как это сделать? Во-первых, фактический код загрузки должен быть помещен в функцию:
import urllib import multiprocessing import time def download_images(): image = urllib.URLopener() file_ = 1 name = 1 for i in range(1,1000): try: image.retrieve(«http://mangawriter.com/pics/pic»+str(file_)+».jpeg»,»pic»+str(name)+».jpeg») print «save file %s» %file_ name += 1 file_ += 1 except IOError: file_ += 1
Теперь мы создаем новый multiprocessing.Process объект multiprocessing.Process , передавая функцию выше в качестве своей цели. Этот объект запустит процесс только для выполнения этой функции:
downloader = multiprocessing.Process(target=download_images)
Как только мы создали объект процесса, просто вызовите его метод start() . Это запустит процесс, который будет работать параллельно:
Самый БЫСТРЫЙ стандартный цикл Python − Интеграция с языком Си
downloader.start()
Поскольку он работает параллельно, основная программа продолжает выполняться. Теперь мы определяем тайм-аут и сон на время этого таймаута. В приведенном ниже примере время ожидания составляет 15 секунд:
timeout = 15 time.sleep(timeout)
По завершении таймаута просто прекратите процесс загрузки:
downloader.terminate()
Полную программу можно найти здесь.
Не лучший, но удобный способ:
Вы можете создать дочерний поток с помощью модуля threading передачи, чтобы установить это, и установите time.sleep в своем основном потоке, поэтому, когда время не работает, вы можете убить дочерний поток.
EDIT: только что-то вроде этого:
import threading import urllib def child(file_, name): try: image = urllib.URLopener() image.retrieve(«http://mangawriter.com/pics/pic»+str(file_)+».jpeg»,»pic»+str(name)+».jpeg») print «save file %s» % file_ except IOError: pass file_ = 1 name = 1 for i in range(1,1000): t = threading.Thread(target = child, args = (file_, name)) t.daemon = True t.start() t.join(timeout = 10) file_ += 1 name += 1
Это действительно работает для меня, и это очень просто. Предположим, что мы хотим остановить через 25 секунд.
import timeit #we will need the command default_timer() that checks the actual time start = timeit.default_timer() while timeit.default_timer()-start
Источник: techarks.ru
Python: Как завершить программу
Важной частью любой программы на Python является правильное завершение. При наличии условий, которые требуют немедленного прекращения работы программы, существуют различные методы, которые могут быть использованы для ее безопасного и корректного завершения.
#21. Операторы циклов break, continue и else | Python для начинающих
Выход из программы с помощью sys.exit()
Модуль sys в Python предоставляет функцию exit(), которую можно использовать для завершения программы. Для использования этого метода сначала необходимо импортировать модуль sys:
import sys sys.exit()
Выход из программы с помощью os._exit()
Модуль os также предоставляет функцию для выхода из программы. Функция _exit() может быть использована для немедленного завершения процесса:
import os os._exit(0)
Прерывание цикла с помощью break
Оператор break в Python используется для прерывания цикла. Если оператор break выполнен внутри цикла, цикл немедленно прекращается:
for i in range(10): if i == 5: break
Исключения и завершение программы
Вы также можете завершить программу, вызвав исключение. Если исключение не обрабатывается, программа завершится:
raise SystemExit(«Программа завершилась»)
Эти методы являются основными способами завершения программы в Python, и их использование будет зависеть от конкретных требований вашего приложения.
- Получить ссылку
- Электронная почта
- Другие приложения
Как сделать шашки на python
Как сделать шашки на Python Как сделать шашки на Python В этой статье мы рассмотрим, как создать простую игру в шашки на Python с использованием библиотеки Pygame. Подготовка Для начала установите библиотеку Pygame, используя следующую команду: pip install pygame Создание доски import pygame pygame.init() WIDTH, HEIGHT = 800, 800 ROWS, COLS = 8, 8 SQUARE_SIZE = WIDTH // COLS WHITE = (255, 255, 255) BLACK = (0, 0, 0) RED = (255, 0, 0) BLUE = (0, 0, 255) def draw_board(win): win.fill(WHITE) for row in range(ROWS): for col in range(row % 2, COLS, 2): pygame.draw.rect(win, BLACK, (row * SQUARE_SIZE, col * SQUARE_SIZE, SQUARE_SIZE, SQUARE_SIZE)) def main(): win = pygame.display.set_mode((WIDTH, HEIGHT)) pygame.display.set_caption(«Checkers») clock = pygame.time.Clock() run = True while run: clock.tick(60) for event in pygame.event.get(): if event.ty
Метод штрафных функций python
Метод штрафных функций Python Метод штрафных функций Python Метод штрафных функций является одним из способов оптимизации функций с ограничениями. В этой статье будет рассмотрен пример использования метода штрафных функций на языке программирования Python. Основы метода штрафных функций Метод штрафных функций предполагает замену задачи с ограничениями на эквивалентную задачу без ограничений. Для этого к целевой функции добавляется штрафной член, который штрафует недопустимые решения, делая их менее предпочтительными для оптимизации. Пример использования метода штрафных функций в Python Рассмотрим пример оптимизации функции с ограничениями с помощью метода штрафных функций на Python. Задача: минимизировать функцию f(x) = x^2 с ограничением g(x) = x — 2 >= 0 . import numpy as np from scipy.optimize import minimize def f(x): return x**2 def g(x): return x — 2 def penalty_function(x, r): return f(x) + r * np.maximum(-g(
Typescript ассоциативный массив
Узнай все о Typescript ассоциативных массивах! Используй интерфейс Record, чтобы определить типы ключей и значений, и храни данные со сложным или динамическим ключем! Typescript Associative Array В Typescript, ассоциативные массивы могут быть определены с помощью интерфейса Record . Этот интерфейс позволяет задать тип ключей и значений в массиве. interface Record < [key: string]: any; >const myArray: Record = <>; myArray[«key1»] = «value1»; myArray[«key2»] = 2; В данном примере, мы определяем интерфейс Record , который позволяет использовать любые строковые ключи с любыми значениями. Затем мы создаем переменную myArray , которая использует этот интерфейс, и добавляем в нее два элемента. Также можно определять типы для ключей и значений, чтобы быть уверенным в том, что в массиве будут только определенные типы данных. interface Record < [key: string]
Источник: www.articleshub.net
Русские Блоги
Многопоточная программа Python с ручным прерыванием (Ctrl-C)
вести
Источником вдохновения по-прежнему является проект фреймворка краулера.pycrawler, На искателя не влияет сигнал прерывания с клавиатуры, когда он работает как дочерний поток, и Ctrl-C не может завершить работу всего искателя. Другой сценарий — многопоточный стресс-тест: если его нужно завершить досрочно, Ctrl-C все равно не сможет завершить всю программу. В дополнение к простому и грубому использованию команды kill для принудительного завершения, эта статья предложит простое и выполнимое решение.
Стоит отметить, что производительность двух версий Python 2 и 3 в тесте не согласована, поэтому две версии используются для тестирования отдельно.
Оригинальный блог
тестовая среда
- Python2 2.7.9
- Python3 3.4.2
- Mac OS X Yosemite 10.10.3
Класс дочернего потока
import time from threading import Thread class CountDown(Thread): def __init__(self): super(CountDown, self).__init__() def run(self): num = 100 print(‘slave start’) for i in range(10, 0, -1): print(‘Num: ‘.format(num/i)) time.sleep(1) print(‘slave end’)
Первый случай неудачи
Код основного потока
if __name__ == ‘__main__’: print(‘main start’) CountDown().start() print(‘main end’)
Используйте Python2 для тестирования и завершения работы вручную до окончания выполнения:
main start slave start main end Num: 10 Num: 11 ^CNum: 12 Num: 14 Num: 16 Num: 20 Num: 25 Num: 33 Num: 50 Num: 100 slave end Exception KeyboardInterrupt in ignored
Видно, что когда он доходит до третьей строки, он завершается вручную. Основной поток завершился раньше, а дочерний поток продолжает выполняться до конца, а затем выдает неперехваченное исключение. Стоит отметить, что нет Traceback Выход.
Затем используйте Python3 для проверки того же кода:
main start slave start main end Num: 10.0 Num: 11.11111111111111 Num: 12.5 ^CException ignored in: Traceback (most recent call last): File «/usr/local/Cellar/python3/3.4.3/Frameworks/Python.framework/Versions/3.4/lib/python3.4/threading.py», line 1294, in _shutdown t.join() File «/usr/local/Cellar/python3/3.4.3/Frameworks/Python.framework/Versions/3.4/lib/python3.4/threading.py», line 1060, in join self._wait_for_tstate_lock() File «/usr/local/Cellar/python3/3.4.3/Frameworks/Python.framework/Versions/3.4/lib/python3.4/threading.py», line 1076, in _wait_for_tstate_lock elif lock.acquire(block, timeout): KeyboardInterrupt
Произошла интересная вещь: основной поток все еще завершился рано, а дочерний поток также был принудительно завершен после ручного завершения, хотя он был напечатан Traceback Информация, но такая же, как в предыдущем примере Exception ignored 。
Второй случай неудачи
Код основного потока, теперь вызовите метод join (), чтобы заставить основной поток ждать завершения дочернего потока:
if __name__ == ‘__main__’: print(‘main start’) td = CountDown() td.start() td.join() print(‘main end’)
Как и выше, используйте Python2 для проверки:
main start slave start Num: 10 Num: 11 Num: 12 ^CNum: 14 Num: 16 Num: 20 Num: 25 Num: 33 Num: 50 Num: 100 slave end Traceback (most recent call last): File «multithread.py», line 23, in td.join() File «/usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python2.7/threading.py», line 949, in join self.__block.wait() File «/usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python2.7/threading.py», line 340, in wait waiter.acquire() KeyboardInterrupt
Видно, что после того, как основной поток вызывает метод join (), wait блокируется и ожидает выхода дочернего потока. После выхода дочернего потока основной поток получает блокировку и реагирует на сигнал прерывания, генерирует исключение и распечатывает информацию, main end Одна строка не печатается.
Затем используйте Python3 для проверки:
main start slave start Num: 10.0 Num: 11.11111111111111 Num: 12.5 ^CTraceback (most recent call last): File «multithread.py», line 23, in td.join() File «/usr/local/Cellar/python3/3.4.3/Frameworks/Python.framework/Versions/3.4/lib/python3.4/threading.py», line 1060, in join self._wait_for_tstate_lock() File «/usr/local/Cellar/python3/3.4.3/Frameworks/Python.framework/Versions/3.4/lib/python3.4/threading.py», line 1076, in _wait_for_tstate_lock elif lock.acquire(block, timeout): KeyboardInterrupt Num: 14.285714285714286 Num: 16.666666666666668 Num: 20.0 Num: 25.0 Num: 33.333333333333336 Num: 50.0 Num: 100.0 slave end
Волшебство произошло снова. Основной поток ответил на сигнал прерывания, ожидая дочернего потока, распечатал информацию и завершил работу. В это время дочерний поток не был затронут и продолжил выполнение до конца.
Мышление
Из python3 Traceback Из информации видно, что даже если метод join () не вызывается явно, основной поток автоматически вызывает логику join () после завершения выполнения ( line 1294, in _shutdown ), и влияние каждого метода на дочерний поток непоследовательно: дочерний поток будет продолжать выполняться, не подвергаясь влиянию при явном вызове; когда он вызывается автоматически, дочерний поток завершает работу с основным потоком.
Согласно Traceback Информационное представление исходного кода Python3:
def _shutdown(): # Obscure: other threads may be waiting to join _main_thread. That’s # dubious, but some code does it. We can’t wait for C code to release # the main thread’s tstate_lock — that won’t happen until the interpreter # is nearly dead. So we release it here. Note that just calling _stop() # isn’t enough: other threads may already be waiting on _tstate_lock. tlock = _main_thread._tstate_lock # The main thread isn’t finished yet, so its thread state lock can’t have # been released. assert tlock is not None assert tlock.locked() tlock.release() _main_thread._stop() t = _pickSomeNonDaemonThread() while t: t.join() t = _pickSomeNonDaemonThread() _main_thread._delete() def _pickSomeNonDaemonThread(): for t in enumerate(): if not t.daemon and t.is_alive(): return t return None
Как видно из исходного кода, основной поток вызвал _stop() Метод, а затем цикл, чтобы дождаться завершения всех процессов, не являющихся демонами, и, наконец, вызвать _delete() Метод заканчивается. Таким образом, хотя основной поток выполнил весь код, на самом деле он не завершается. Вместо этого он ожидает выполнения всех дочерних потоков, не являющихся демонами, прежде чем освободить ресурсы и выйти из программы (все потоки демона также уничтожаются). В этом процессе основной поток Потоки только занимают ресурсы, но не выполняют логику (я понимаю, что они не будут реагировать на сигналы прерывания).
Итак, приходим к выводу:
- Нет вызова join() В случае сбоя основной поток выходит из логики выполнения, но не освобождает ресурс и не отвечает на сигнал прерывания. В это время на сигнал прерывания отвечает дочерний поток, поэтому в случае сбоя 1 программа успешно завершается.
- Явный вызов join() В случае сбоя основной поток не выполняет последующий код, а ждет, пока дочерний поток освободит блокировку, чтобы он мог ответить на сигнал прерывания, поэтому в случае сбоя 2 основной поток реагирует на сигнал прерывания и выполняет логику выхода (переход к предыдущему случаю). Поток не затронут, и программа завершится после выполнения.
Но что касается разницы между Python2 и Python3, я все еще не хочу ее понимать. Первоначальная идея состоит в том, что логика (или порядок) обработки исключений в 2 и 3 несовместима, в результате чего все исключения в 2 возникают только тогда, когда основной поток действительно завершается. Это захвачено. Планирую узнать об этом, добавлю ссылку на вопрос позже
решение
Сказав так много, наконец, решение достигнуто. Идея такова: установите дочерний поток как поток демона и вызовите основной поток после запуска дочернего потока. isAlive() Метод имитирует процесс соединения вручную.
Код выглядит следующим образом:
if __name__ == ‘__main__’: print(‘main start’) td = CountDown() td.setDaemon(True) td.start() try: while td.isAlive(): pass except KeyboardInterrupt: print(‘stopped by keyboard’) print(‘main end’)
Результат теста (результаты выполнения Python2 и 3 согласованы):
main start slave start Num: 10 Num: 11 Num: 12 Num: 14 Num: 16 ^Cstopped by keyboard main end
Еще одно преимущество этой схемы состоит в том, что основной поток может продолжать выполнять логику последствий.
Морской узел
- Я чувствую, что такое решение — нехарактерный трюк. Я долго думал об этом, прежде чем придумал его. Не знаю, применимо ли оно в конкретных приложениях. В конце концов, проекты, с которыми я сейчас связался, слишком малы.
- Из этого примера видно, что помимо основных различий, упомянутых на официальном сайте, существует множество тонких различий между Python2 и Python 3. Эти различия могут иметь определенное влияние на определенные конкретные программы, и их можно найти только медленно.
- Эта статья считается первой из сложных многопоточных техник. Еще одна важная проблема в многопоточных программах — это то, как основной поток фиксирует исключения, генерируемые подпотоками. Я разработал план, и у меня есть время его проверить.
- Если есть что-то не так или есть лучшее решение, добро пожаловать в обсуждение.
- Спасибо ~
Источник: russianblogs.com