Питон веб-сканеры (2) Обзор программирования Python

Запись файлов

Защиту storFile (данные, имя файла, метод = 'A'): 
    с открытой (имя_файла, метод перевода строки = '') , как F: 
        f.write (данные) 
        проходят 
    проходят 

storFile ( '123', '1.txt')

Файл Read

с открытой ( '1.txt', 'R') , как F: 
    печать (f.read ())

Последовательность операций

Данные могут быть сохранены в памяти и становится долю, чтобы достичь состояния сохранности. cPickle написан на С, высокой эффективностью, приоритетного использования. Если нет использовать рассол. рассол с помощью дампа и отвалов реализовать сериализацию.

попробовать: 
    импорт cPickle как рассол , 
кроме ImportError: 
    импорт рассола 
д = ДИКТ (URL = 'index.html', название = '1', содержание = '2') 
F = открыт ( '2.txt', 'термометра') 
рассол .dump (д, е) 
f.close () для 
печати (pickle.dumps (д))

Deserialize

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

попробуйте: 
    импорт cPickle как рассол , 
кроме ImportError: 
    импорт рассол 
е = открытая ( '2.txt', 'гь') 
d = pickle.load (е) 
f.close () 
печать (d)

Создание мульти-процесс

использование Os из многопроцессных репликативной вилки точно такой же процесса, и ребенка возвращается 0, возвращение дочернего процесса родительского процесса. Только в Linux / Unix в.

импорт ОС 
если __name__ == '__main__': 
　　PID = os.fork () , 
　　если PID <0: 
　　    печать ( 'ошибка ПИД - регулятора') 
　　Элиф PID == 0: 
 　　   печать ( 'ребенок, родитель PID', os.getpid (), os.getppid ()) 
　　еще: 
 　　   печать ( 'родитель PID, создать ребенок', os.getpid, ИДП)

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

импорт ОС 
из многопроцессорных импорта Процесс 
четкости run_proc (имя): 
    печать ( 'имя, ребенок Pid работает', имя, os.getpid ()) , 
если __name__ == '__main__': 
    печать ( 'родительский PID', os.getpid () ) 
    для г в интервале (5): 
        р = Process (целевой = run_proc, Args = (ул (I),)) 
        печать ( 'Процесс начнет') 
        p.start () 
    p.join () 
    печать ( 'конец' )

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

импорт ОС 
от многопроцессорных импорта процесса, бассейн 
импорт случайных, время 
четкости run_proc (имя): 
    печать ( 'имя, дочернего процесса работает', имя, os.getpid ()) 
    time.sleep (random.random () * 10) 
    печать ( 'имя, ребенок Pid работает конец', имя, os.getpid ()) , 
если __name__ == '__main__': 
    печать ( 'родительский PID', os.getpid ()) 
    р = бассейн (процессы = 3) 
    для я в диапазоне (10): 
        p.apply_async (run_proc, Args = (я)) 
    печать ( 'ждать') 
    p.close () 
    p.join () 
    печать ( 'конец')

межпроцессная коммуникация

очереди Communications

Подходит для связи между несколькими процессами, использование пут и получить методы.

импорт ОС 
от многопроцессорной процесса импорта, очередей 
времени импорта, случайной 
четкости write_proc (Q, URL): 
    печать ( «ш обработка», os.getpid (), «работает») 
    для и в адресах: 
        q.put (и) 
        печати ( 'говоря:', и) 
        time.sleep (random.random ()) 
    проходят 
защиту read_proc (д): 
    печать ( 'г обработка', os.getpid (), 'бежит') , 
    а (True): 
        и = q.get (True) 
        печати ( 'получим:', и) 
    проходят , 

если __name__ == '__main__': 
    д = Queue () 
    w1 = Process (цель = write_proc, Args = (Q, [ 'u1', 'u2' , 'и3'])))) 
    W1.start () 
    w2.start () 
    w2 = Процесс (мишень = write_proc, Args = (д, [ 'и4','U5', 'u6']))
    R1 = Процесс (цель = read_proc, Args = (Q,))
    r1.start () 
    w1.join () 
    w2.join () 
    r1.terminate () 
    передача

Труба связи

Трубы и conn2 метод возвращает conn1, и может посылать и принимать полнодуплексный режим (дуплекс трубы метод управления параметрами), путем отправки и управления Recv.

импорт ОС 
от многопроцессорной процессе импорта труб 
время импорта, случайной 
четкости send_proc (р, URL): 
    печать ( «s обработка», os.getpid (), «работает») 
    для и в адресах: 
        p.send (и) 
        печати ( 'отправить:', U) 
        time.sleep (random.random ()) 
    передать 
четкости receive_proc (P): 
    печать ( 'г обработка', os.getpid (), 'работает') , 
    а (True): 
        и = p.recv () для 
        печати ( 'получим:', U) 
    проходит , 

если __name__ == '__main__': 
    р = Труба () 
    р1 = Процесс (мишень = send_proc, Args = (р [0], [ 'u1',» и2' , 'и3'])) 
    р2 = Процесс (мишень = receive_proc, Args = (р [1],)) 
    P1.start ()
    p2.start () 

    p1.join () 
    p2.terminate () 
    передача

Многопоточность

Чуть больше понимания . Создание многопоточных модуля использование многопоточности

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

четкости run_proc (URL): 
    печать (. 'имя', потоковой threading.current_thread имя ()) 
    для и в URL: 
        . печать (threading.current_thread) имя ( '----->' , и) 
        time.sleep (random.random ()) 
    печать ( 'конец', threading.current_thread () имя). 
    передать , 

если __name__ == '__main__': 
    печать. ( 'бег:', threading.current_thread () имя ) 
    w1 = threading.Thread (мишень = run_proc, имя = 'Т1', Args = ([ 'u1', 'u2', 'и3'])) 
    w2 = threading.Thread (мишень = run_proc, имя = 'Т2 », арг = ([ 'и4', 'U5', 'U6'],)) 
    w1.start () 
    w2.start () 
    w1.join () 
    w2.присоединиться () 
    печать ( «конец») 
    проход

Threading.Thread использовать наследование для создания нитей категории: Исходный код: https://github.com/qiyeboy/SpiderBook

импорт случайный 
импорта потокового 
время импорта 
класс MyThread (threading.Thread): 
    Защита __init __ (я, имя, URL): 
        threading.Thread .__ INIT __ (я, имя = имя) 
        self.urls = URLs 

    Защиты работать (самостоятельно): 
        печать (» Текущий% s работает ...»% threading.current_thread имя ()). 
        для URL в self.urls: 
                . печать ( '---- >>>% s' % (threading.current_thread) имя% s (, URL)) 
                time.sleep (random.random ()) 
        печать ( "% s закончился.% threading.current_thread имя) (). 
        
печать ( '% s работает ...% threading.current_thread () имя.)  
t1 = MyThread (имя = 'Thread_1', URL = [ 'URL_1', 'url_2', 'url_3'])
t2 = MyThread (имя = 'Thread_2', URLs = [ 'url_4', 'url_5', 'url_6']) 
T1.start () 
t2.start ()
t1.join () 
t2.join () 
печать ( "% s закончился.% threading.current_thread) имя (.)

Синхронизация потоков

Синхронизация потоков в целях защиты данных, есть два варианта блокировки и RLOCK. См . Кроме того, существование глобальной блокировки интерпретатора, ограничение доступа к теме ресурсов ЦП ресурсоемких приложений , как правило, используют несколько процессов. Для ввода - вывода интенсивных приложений, использование многопоточности.

импорт потоковой 
mylock = threading.RLock () 
Num = 0 
класса MyThread (threading.Thread): 
    Защита __init __ (я, имя): 
        threading.Thread .__ INIT __ (я, имя = имя) 

    Защита запуска (сам): 
        глобальный Num , 
        а правда : 
            mylock.acquire () для 
            печати ( '% s заблокирован, номер:% d' имя, Num)% (threading.current_thread ().) , 
            если число> = 100: 
                mylock.release () для 
                печати ( «% s выпущен, номер :% d '% (. threading.current_thread () имя, Num)) 
                перерыв 
            Num + = 1 
            печать ( '% s выпущен, номер:.% d' % (threading.current_thread () наименование, Num))
            mylock.release () 
 , 
если __NAME __ == '__main__': 
    thread1 = MyThread (' Thread_1')
    thread2 = MyThread ( 'Thread_2') 
    thread1.start () 
    thread2.start ()