python 的多线程、多进程学习总结

基本概念

进程

一个运行的程序称做进程

给函数的执行计时(装饰器实现）

这是利用装饰器的特性来，来完成对函数执行完成的计算。

import time

def fn_timer(func):
    def function_timer(*args, **kwargs):
        t0 = time.time()
        result = func(*args, **kwargs)
        t1 = time.time()
        print("Total time running '{func_name}': {time} secondes".format(
            func_name=func.__name__, time=str(t1-t0)[:9]
        ))
        return result
    return function_timer

@fn_timer
def print_11():
    print('11')
    
print_11()

11
Total time running 'print_11': 6.4134597 secondes

python 多进程（demo）

import multiprocessing
import time


def clock_1(interval):
    while True:
        print('--1--: The time is :', time.ctime())
        time.sleep(interval)
        
        
def clock_2(interval):
    while True:
        print('--2--: The time is :', time.ctime())
        time.sleep(interval)

print('This is a test for multiprocessing')
p1 = multiprocessing.Process(target=clock_1, args=(3,))
p1.start()

p2 = multiprocessing.Process(target=clock_2, args=(4,))
p2.start()
print('SubProcess is going to start')
time.sleep(16)
print('SubProcess is going to be shutdown')
p1.terminate()
print('Clock_1 has been terminated')
p2.terminate()
print('Clock_2 has been terminated')
print('1 pid is:', p1.pid)
print('2-SubProcess name is', p2.name)
print('2-ExitCode is', p2.exitcode)

This is a test for multiprocessing
--1--: The time is : Sun Dec 24 17:35:49 2017
--2--: The time is : Sun Dec 24 17:35:49 2017
SubProcess is going to start
--1--: The time is : Sun Dec 24 17:35:52 2017
--2--: The time is : Sun Dec 24 17:35:53 2017
--1--: The time is : Sun Dec 24 17:35:55 2017
--2--: The time is : Sun Dec 24 17:35:57 2017
--1--: The time is : Sun Dec 24 17:35:58 2017
--2--: The time is : Sun Dec 24 17:36:01 2017
--1--: The time is : Sun Dec 24 17:36:01 2017
--1--: The time is : Sun Dec 24 17:36:04 2017
SubProcess is going to be shutdown
Clock_1 has been terminated
Clock_2 has been terminated
1 pid is: 40102
2-SubProcess name is Process-3
2-ExitCode is None

python 进程间通信

import multiprocessing
import time


def adder(pipe):
    print('Server SubProcess start ...')
    server_p, client_p = pipe
    client_p.close()
    
    while True:
        try:
            x, y = server_p.recv()
        except EOFError:
            print(str(EOFError))
            time.sleep(5)
            break
        result = x + y
        server_p.send(result)
    print('Server done ...')
    
if __name__ == '__main__':
    (server_p, client_p) = multiprocessing.Pipe()
    print('Pipe Created ...')
    time.sleep(3)
    adder_p = multiprocessing.Process(target=adder, args=((server_p, client_p),))
    adder_p.start()
    server_p.close()

    print('Begin to test...')
    client_p.send((9, 9))
    time.sleep(1)
    print(client_p.recv())

    client_p.send(('You','UP!'))
    print(client_p.recv())

    time.sleep(5)
    client_p.close()
    #if MainProcess shutdown, the SubProcess created by it will also be shutdown
    #So U should wait until the SubProcess done...
    adder_p.join()

    input('Enter for Exit...')

Pipe Created ...
Server SubProcess start ...
Begin to test...
18
YouUP!
<class 'EOFError'>
Server done ...
Enter for Exit...

Python 高级编程

第二章

生成器模版

def my_generator():
    try:
        yield 'something'
    except ValueError:
        yield 'dealing with the exception'
    finally:
        print("ok let's clean")

gen = my_generator()
gen.__next__()

'something'

生成器表达式

iter_list = (x**2 for x in range(10) if x % 2 == 0)
for el in iter_list:
    print(el)

装饰器

# 简单装饰器
def mydecorator(func):
    def _mydecorator(*args, **kwargs):
        res = func(*args, **kwargs)
        return res
    return _mydecorator

带参数的简单装饰器

def mydecorator(arg1, arg2):
    def _mydecorator(func):
        def __mydecorator(*args, **kwargs):
            res = func(*args, **kwargs)
            return res
        return __mydecorator
    return _mydecorator

第三章

子类化内建类型

class DistinctError(Exception):
    pass


class distincdict(dict):
    def __setitem__(self, key, value):
        try:
            value_index = list(self.values()).index(value)
            existing_key = list(self.keys())[value_index]
            if existing_key != key:
                raise DistinctError(("This value already exists for '%s'") % str(self[existing_key]))
        except ValueError:
            pass
        
        super(distincdict, self).__setitem__(key, value)
        
        
my = distincdict()
my['key'] = 'value'
my['other_key'] = 'value'

---------------------------------------------------------------------------

DistinctError                             Traceback (most recent call last)

<ipython-input-62-9f4b19dff490> in <module>()
     18 my = distincdict()
     19 my['key'] = 'value'
---> 20 my['other_key'] = 'value'
     21 


<ipython-input-62-9f4b19dff490> in __setitem__(self, key, value)
      9             existing_key = list(self.keys())[value_index]
     10             if existing_key != key:
---> 11                 raise DistinctError(("This value already exists for '%s'") % str(self[existing_key]))
     12         except ValueError:
     13             pass


DistinctError: This value already exists for 'value'

访问超类中的方法

class Mama():
    def says(self):
        print('Do your homework')
        
        
class Sister(Mama):
    def says(self):
        super().says()
        print('and clean your bedroom')
        
        
anita = Sister()
anita.says()

Do your homework
and clean your bedroom

MyType = type('MyType', (object,), {'a': 1})
ob = MyType()
type(ob)
ob.a

单例模式

class Singleton():
    def __new__(cls, *args, **kw):
        if not hasattr(cls, '_instance'):
            orig = super(Singleton, cls)
            cls._instance = orig.__new__(cls, *args, **kw)
        return cls._instance
    
    
class MyClass(Singleton):
    a = 1
    

one = MyClass()
two = MyClass()
one.a = 3
two.a

Python 中的 classmethod 和 staticmethod 有什么具体用途？

## 类方法用途展示，可以方位类属性

class Kls:
    no_inst = 0
    def __init__(self):
        Kls.no_inst = Kls.no_inst + 1
    
    @classmethod
    def get_no_of_instacne(cls):
        return cls.no_inst
        
ik1 = Kls()
print(ik1.get_no_of_instacne())
ik2 = Kls()
print(ik2.get_no_of_instacne())
print(Kls.get_no_of_instacne())

1
2
2

python 装饰器官方示例

Creating Well-Behaved Decorators / "Decorator decorator"

def simple_decorator(decorator):
    def new_decorator(f):
        g = decorator(f)
        g.__name__ = f.__name__
        g.__doc__ = f.__doc__
        g.__dict__.update(f.__dict__)
        return g
    
    new_decorator.__name__ = decorator.__name__
    new_decorator.__doc__ = decorator.__doc__
    new_decorator.__dict__.update(decorator.__dict__)
    return new_decorator


@simple_decorator
def my_simple_logging_decorator(func):
    def you_will_never_see_this_name(*args, **kwargs):
        print('Calling {}'.format(func.__name__))
        return func(*args, **kwargs)
    return you_will_never_see_this_name


@my_simple_logging_decorator
def double(x):
    'Doubles a number'
    return 2 * x

assert double.__name__ == 'double'
assert double.__doc__ == 'Doubles a number'
print(double(155))

Calling double
310

Property Definition

import sys


def propget(func):
    locals = sys._getframe(1).f_locals
    name = func.__name__
    prop = locals.get(name)
    if not isinstance(prop, property):
        prop = property(func, doc=func.__doc__)
    else:
        doc = prop.__doc__ or func.__doc__
        prop = property(func, prop.fset, prop.fdel)
    return prop


def propset(func):
    locals = sys._getframe(1).f_locals
    name = func.__name__
    prop = locals.get(name)
    if not isinstance(prop, property):
        prop = property(None, func, doc=func.__doc__)
    else:
        doc = prop.__doc__ or func.__doc__
        prop = property(prop.fget, func, prop.fdel, doc)
    return prop


def propdel(func):
    locals = sys._getframe(1).f_locals
    name = func.__name__
    prop = locals.get(name)
    if not isinstance(prop, property):
        prop = property(None, None, func, doc=func.__doc__)
    else:
        prop = property(prop.fget, prop.fset, func, prop.__doc__)
    return prop


class Example():
    
    @propget
    def myattr(self):
        return self._half * 2
    
    @propset
    def myattr(self, value):
        self._half = value / 2
        
    @propdel
    def myattr(self):
        del self._half

Yet another property decorator

import builtins


def property(func):
    keys = 'fget', 'fset', 'fdel'
    func_locals = {'doc': func.__doc__}
    def probe_func(frame, event, arg):
        if event == 'return':
            locals = frame.f_locals
            func_locals.update(dict((k, locals.get(k)) for k in keys))
            sys.settrace(None)
        return probe_func
    sys.settrace(probe_func)
    func()
    return builtins.property(**func_locals)


from math import radians, degrees, pi


class Angle():
    def __init__(self, rad):
        self._rad = rad
        
    @property
    def rad():
        """The angle in radians"""
        def fget(self):
            return self._rad
        
        def fset(self, angle):
            if isinstance(angle, Angle):
                angle = angle.rad
            self._rad = float(angle)
        
        @property
        def deg():
            """The angle in degrees"""
            def fget(self):
                return degrees(self._rad)
            def fset(self, angle):
                if isinstance(angle, Angle):
                    angle = angle.deg
                self._rad = radians(angle)

Memoize

Here's a memoizing class.

import collections
import functools


class memoized():
    
    def __init__(self, func):
        self.func = func
        self.cache = {}
        
    def __call__(self, *args):
        if not isinstance(args, collections.Hashable):
            return self.func(*args)
        if args in self.cache:
            return self.cache[args]
        else:
            value = self.func(*args)
            self.cache[args] = value
            return value
        
    def __repr__(self):
        '''Return the function's docstring'''
        return self.func.__doc__
    
    def __get__(self, obj, objtype):
        '''Support instance methods.'''
        return functools.partial(self.__call__, obj)
    
@memoized
def fibonacci(n):
    """Return the nth fibonacci number"""
    if n in (0, 1):
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(12))

Alternate memoize as nested functions

def memoize(obj):
    cache = obj.cache = {}
    @functools.wraps(obj)
    def memoizer(*args, **kwargs):
        if args not in cache:
            cache[args] = obj(*args, **kwrags)
        return cache[args]
    return memoizer

Here's a modified version that also respects kwargs.

def memoize(obj):
    cache = obj.cache = {}
    
    @functools.wraps(obj)
    def memoizer(*args, **kwargs):
        key = str(args) + str(kwargs)
        if key not in cache:
            cache[key] = obj(*args, **kwargs)
        return cache[key]
    return memoizer

Alternate memoize as dict subclass

class memoize(dict):
    
    def __init__(self, func):
        self.func = func
        
    def __call__(self, *args):
        return self[args]
    
    def __missing__(self, key):
        result = self[key] = self.func(*key)
        return result
    
    
@memoize
def foo(a, b):
    return a, b

Alternate memoize that stores cache between executions

import pickle
import collections
import functools
import inspect
import os.path
import re
import unicodedata


class Memorize():
    
    def __init__(self, func):
        self.func = func
        self.set_parent_file()
        self.__name__ = self.func.__name__
        self.set_cache_filename()
        if self.cache_exists():
            self.read_cache()
            if not self.is_safe_cache():
                self.cache = {}
        else:
            self.cache = {}
            
    def __call__(self, *args):
        if not isinstance(args, collections.Hashable):
            return self.func(*args)
        if args in self.cache:
            return self.cache[args]
        else:
            value = self.func(*args)
            self.cache[args] = value
            self.save_cache()
            return value
        
    def set_parent_file(self):
        rel_parent_file = inspect.stack()[-1].filename
        self.parent_filepath = os.path.abspath(rel_parent_file)
        self.parent_filename = _filename_from_path(rel_parent_file)
        
    def set_cache_filename(self):
        filename = _slugify(self.parent_filename.replace('.py', ''))
        funcname =

python 装饰器官方示例

Creating Well-Behaved Decorators / "Decorator decorator"

def simple_decorator(decorator):
    def new_decorator(f):
        g = decorator(f)
        g.__name__ = f.__name__
        g.__doc__ = f.__doc__
        g.__dict__.update(f.__dict__)
        return g
    
    new_decorator.__name__ = decorator.__name__
    new_decorator.__doc__ = decorator.__doc__
    new_decorator.__dict__.update(decorator.__dict__)
    return new_decorator


@simple_decorator
def my_simple_logging_decorator(func):
    def you_will_never_see_this_name(*args, **kwargs):
        print('Calling {}'.format(func.__name__))
        return func(*args, **kwargs)
    return you_will_never_see_this_name


@my_simple_logging_decorator
def double(x):
    'Doubles a number'
    return 2 * x

assert double.__name__ == 'double'
assert double.__doc__ == 'Doubles a number'
print(double(155))

Calling double
310

Property Definition

import sys


def propget(func):
    locals = sys._getframe(1).f_locals
    name = func.__name__
    prop = locals.get(name)
    if not isinstance(prop, property):
        prop = property(func, doc=func.__doc__)
    else:
        doc = prop.__doc__ or func.__doc__
        prop = property(func, prop.fset, prop.fdel)
    return prop


def propset(func):
    locals = sys._getframe(1).f_locals
    name = func.__name__
    prop = locals.get(name)
    if not isinstance(prop, property):
        prop = property(None, func, doc=func.__doc__)
    else:
        doc = prop.__doc__ or func.__doc__
        prop = property(prop.fget, func, prop.fdel, doc)
    return prop


def propdel(func):
    locals = sys._getframe(1).f_locals
    name = func.__name__
    prop = locals.get(name)
    if not isinstance(prop, property):
        prop = property(None, None, func, doc=func.__doc__)
    else:
        prop = property(prop.fget, prop.fset, func, prop.__doc__)
    return prop


class Example():
    
    @propget
    def myattr(self):
        return self._half * 2
    
    @propset
    def myattr(self, value):
        self._half = value / 2
        
    @propdel
    def myattr(self):
        del self._half

Yet another property decorator

import builtins


def property(func):
    keys = 'fget', 'fset', 'fdel'
    func_locals = {'doc': func.__doc__}
    def probe_func(frame, event, arg):
        if event == 'return':
            locals = frame.f_locals
            func_locals.update(dict((k, locals.get(k)) for k in keys))
            sys.settrace(None)
        return probe_func
    sys.settrace(probe_func)
    func()
    return builtins.property(**func_locals)


from math import radians, degrees, pi


class Angle():
    def __init__(self, rad):
        self._rad = rad
        
    @property
    def rad():
        """The angle in radians"""
        def fget(self):
            return self._rad
        
        def fset(self, angle):
            if isinstance(angle, Angle):
                angle = angle.rad
            self._rad = float(angle)
        
        @property
        def deg():
            """The angle in degrees"""
            def fget(self):
                return degrees(self._rad)
            def fset(self, angle):
                if isinstance(angle, Angle):
                    angle = angle.deg
                self._rad = radians(angle)

Memoize

Here's a memoizing class.

import collections
import functools


class memoized():
    
    def __init__(self, func):
        self.func = func
        self.cache = {}
        
    def __call__(self, *args):
        if not isinstance(args, collections.Hashable):
            return self.func(*args)
        if args in self.cache:
            return self.cache[args]
        else:
            value = self.func(*args)
            self.cache[args] = value
            return value
        
    def __repr__(self):
        '''Return the function's docstring'''
        return self.func.__doc__
    
    def __get__(self, obj, objtype):
        '''Support instance methods.'''
        return functools.partial(self.__call__, obj)
    
@memoized
def fibonacci(n):
    """Return the nth fibonacci number"""
    if n in (0, 1):
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(12))

Alternate memoize as nested functions

def memoize(obj):
    cache = obj.cache = {}
    @functools.wraps(obj)
    def memoizer(*args, **kwargs):
        if args not in cache:
            cache[args] = obj(*args, **kwrags)
        return cache[args]
    return memoizer

Here's a modified version that also respects kwargs.

def memoize(obj):
    cache = obj.cache = {}
    
    @functools.wraps(obj)
    def memoizer(*args, **kwargs):
        key = str(args) + str(kwargs)
        if key not in cache:
            cache[key] = obj(*args, **kwargs)
        return cache[key]
    return memoizer

Alternate memoize as dict subclass

class memoize(dict):
    
    def __init__(self, func):
        self.func = func
        
    def __call__(self, *args):
        return self[args]
    
    def __missing__(self, key):
        result = self[key] = self.func(*key)
        return result
    
    
@memoize
def foo(a, b):
    return a, b

Alternate memoize that stores cache between executions

import pickle
import collections
import functools
import inspect
import os.path
import re
import unicodedata


class Memorize():
    
    def __init__(self, func):
        self.func = func
        self.set_parent_file()
        self.__name__ = self.func.__name__
        self.set_cache_filename()
        if self.cache_exists():
            self.read_cache()
            if not self.is_safe_cache():
                self.cache = {}
        else:
            self.cache = {}
            
    def __call__(self, *args):
        if not isinstance(args, collections.Hashable):
            return self.func(*args)
        if args in self.cache:
            return self.cache[args]
        else:
            value = self.func(*args)
            self.cache[args] = value
            self.save_cache()
            return value
        
    def set_parent_file(self):
        rel_parent_file = inspect.stack()[-1].filename
        self.parent_filepath = os.path.abspath(rel_parent_file)
        self.parent_filename = _filename_from_path(rel_parent_file)
        
    def set_cache_filename(self):
        filename = _slugify(self.parent_filename.replace('.py', ''))
        funcname =

Python 编程实战-运用设计模式、并发和程序库创建高质量程序

1.python 的创建型设计模式

1.1 抽象工厂模式

class DiagramFactory():
    
    def make_diagram(self, width, height):
        return Diagrame(width, height)
    
    def make_rectangle(self, x, y, width, height, fill="white", \
                       stroke="black"):
        return Rectangle(x, y, text, fontsize)
    
    def make_text(self, x, y, text, fontsize=1):
        return Text(x, y, text, fontsize)
    
    
class SvgDiagramFactory(DiagramFactory):
    def make_diagram(self, width, height):
        return SvgDiagram(width, height)


def create_diagram(factory):
    diagram = factory.make_diagram(30, 7)
    rectangle = factory.make_rectangle(4, 1, 22, 5, "yellow")
    text = factory.make_text(7, 3, "Abstact Factory")
    diagram.add(rectangle)
    diagram.add(text)
    return diagram


def main():
    textDiagram = create_diagram(DiagramFactory())
    txtDiagram.save(textFilename)
    
    svgDiagram = create_diagram(svgDiagramfactory())
    svgDiagram.save(svgFilename)

pythone 学习知识整理

pythone 学习知识整理

python 的多线程、多进程学习总结

基本概念

给函数的执行计时(装饰器实现）

python 多进程（demo）

python 进程间通信

Python 高级编程

第二章

生成器模版

生成器表达式

装饰器

带参数的简单装饰器

第三章

访问超类中的方法

单例模式

Python 中的 classmethod 和 staticmethod 有什么具体用途？

python 装饰器官方示例

Creating Well-Behaved Decorators / "Decorator decorator"

Property Definition

Yet another property decorator

Memoize

Here's a memoizing class.

Alternate memoize as nested functions

Here's a modified version that also respects kwargs.

Alternate memoize as dict subclass

Alternate memoize that stores cache between executions

python 装饰器官方示例

Creating Well-Behaved Decorators / "Decorator decorator"

Property Definition

Yet another property decorator

Memoize

Here's a memoizing class.

Alternate memoize as nested functions

Here's a modified version that also respects kwargs.

Alternate memoize as dict subclass

Alternate memoize that stores cache between executions

Python 编程实战-运用设计模式、并发和程序库创建高质量程序

1.python 的创建型设计模式

1.1 抽象工厂模式