# 不进行转义
print(r'''hello,\n
Python''')

ord('国')

chr(22269)

# 以Unicode表示的str可以编码为指定的bytes
print('abc'.encode('ascii'))
print('中文'.encode('utf-8'))

# 解码从网络或者磁盘上读取的字节流
print(b'abc'.decode('ascii'))
print(b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8'))

"name: %s, age: %.2f" % ('xiaoming', 23.0)

"name: {0}, age: {1:.2f}".format('xiaoming', 23.00)

name = 'xiaoming'
age = 23.0
f"name: {name}, age: {age:.2f}"

people = ['li', 'mu', 'zhang']
people

people[-1]

# 列表添加元素到末尾
people = ['li', 'mu', 'zhang']
people.append('wang')
people

# 删除指定索引元素，默认为0
people = ['li', 'mu', 'zhang']
people.pop(1)
people

# 指定位置插入某个元素
people = ['li', 'mu', 'zhang']
people.insert(1, 'mei')
people

# 直接替换某个元素
people = ['li', 'mu', 'zhang']
people[0] = 'zhang'
people

# 可以进行嵌套索引
people = ['li', ['mu','mei'], 'zhang']
people[1][1]

# 创建空元组
t = ()
t

# 单个元素的元组
t = (1,)

# 多个元素元组
t = (1, 2, 3)
t

# 创建词典
my_dict = {
    'li':12,
    'wang':13,
    'wu':35
}
my_dict

# 查找元素
my_dict['wu']

# 判断元素是否存在，不存在返回默认值
print(my_dict.get('wu', 23))
print(my_dict.get('lv', 18))

# 删除元素
my_dict.pop('wu')
my_dict

s1 = set([1, 3, 4, 4])
s2 = set([4, 5, 5, 4, 8])
s1 & s2

# 添加元素
s1.add(5)
s1

# 移除元素
s2.remove(5)
s2

li = [1, 2, 3, 4]
li.append(5)
print(li)

s = 'abc'
s.replace('a', 'A')
print(s)

# 顺序执行，只要满足其中一个添加就会退出
age = 5
if age <= 7:
    print('child')
elif age <= 18:
    print('teenager')
else:
    print('adult')

x = 1
if x:
    print('True')

# for循环
sum = 0
for i in range(10):
    sum += i
print(sum)

# while循环
sum = 0
n = 0
while n < 10: # 只要条件满足便会一直循环
    sum += n
    n += 1
print(sum)

a = abs
a(-19)

# 函数传入参数的类型检查,使用raise抛出一个错误
def my_abs(x):
    if not isinstance(x, (int, float)):
        raise(TypeError('bad operand type'))
    if x >= 0:
        return x
    else:
        return -x
my_abs('f')

# 返回多个值
def f1(a, b):
    return a+b, a-b
x, y  = f1(2, 3)
print(f'{x}  {y}')

def add(a, b):
    return a+b
add(2,3)

def add(a, b=1):
    return a+b
add(2, 4)

# 函数内部接受到的是一个 tuple
def calc(*numbers):
    sum = 0
    for n in numbers:
        sum += n
    return sum
calc(2,2,4,4,5)

# 如果已经有一个list或tuple
t = tuple([1,2,4,5])
calc(*t)

## 定义关键字参数，多余的会组成一个字典输出
def person(name, age, **kw):
    print(f'name: {name} age: {age} other: {kw}')
person('Bob', 23, city = 'beijing', gender = 'M')

## 调用已经构建好的字典
extra = {'name':'Bob',
         'age':23,
         'city':'Beijing',
         'gender':'M'}
person(**extra)

# 使用*分隔之后的命名关键字参数
def person(name, age, *, city, job):
    print(name, age, city, job)
person('Jack', 24, city='beijing', job='Engineer')

# 如果函数定义有可变参数
def person(name, age, *args, city='Beijing', job):
    print(name, age, args, city, job)
person('Jack', 24, job='Engineer')

# 包含可变参数
def f1(a, b, c=0, *args, **kw,):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
# 不包含可变参数
def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)

f1(1, 2, 3, 'a', 'b', city=99)

f2(1, 2, 4, d=99, ext=None)

# 可以直接组成tuple进行输出
args = (1, 2, 3, 4)
kw = {'d': 99, 'x': '#'}
f1(*args, **kw)

# 简单递归函数
def fact(n):
    if n == 1:
        return 1
    else:
        return n*fact(n-1)
fact(10)

# 尾递归优化
def fact(n):
    return fact_iter(n, 1)

def fact_iter(num, product):
    if num == 1:
        return product
    return fact_iter(num - 1, num * product)
fact(10)

L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
L[0:1]

L[:] # 开辟存储空间，复制列表L

L[0:4:2]

# 判断字符串对象是否是迭代对象
from collections.abc import Iterable
isinstance('abc', Iterable)

# 筛选偶数
[x for x in range(1, 11) if x % 2 == 0]

# 包含if...else...的列表生成式
[x if x % 2 == 0 else -x for x in range(1, 11)]

# 创建给生成器
f = (x for x in range(10))
# next(f)

# 使用循环对生成器进行输出
for n in f:
    print(n)

# 斐波那契数列普通函数
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'

fib(5)

# 斐波那契数列迭代器方式书写
def g_fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'
f = g_fib(6)
for n in f:
    print(n)

for x in [1, 2, 3, 4, 5]:
    pass

# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

# 函数名作为变量
f = abs
f(-1)

# 一个简单的高阶函数
def add(a, b, f):
    return f(a) + f(b)
add(-3, -4, abs)

# 一个简单的map函数运用
def f(x):
    return x*x
li = map(f, [1, 2, 3, 4])
# Iterator是一个惰性序列，需要通过list()转为一个序列输出
list(li)

# 一个int2str直观的例子
li = [1, 2, 3, 4, 5, 7]
new_li = map(str, li)
list(new_li)

from functools import reduce
# 一个对序列求和的简单例子
def add(a, b):
    return a+b

reduce(add, [1, 3, 5, 7, 9])

# 组合map和reduce函数写一个str2int函数
from functools import reduce

DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}

def str2int(s):
    def fn(x, y):
        return x * 10 + y
    def char2num(s):
        return DIGITS[s]
    return reduce(fn, map(char2num, s))
str2int('124')

# 返回偶数序列
def even(n):
    return n%2==0
li = [1, 3, 4, 5, 8]
r = filter(even, li)
list(r)

def is_palindrome(n):
    str_A = str(n)
    str_B = str_A[::-1]
    return str_A == str_B
if list(filter(is_palindrome, range(1, 200))) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101, 111, 121, 131, 141, 151, 161, 171, 181, 191]:
    print('测试成功!')
else:
    print('测试失败!')

L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]

# 按照名称排序
def by_name(t):
    return str.lower(t[0])
L2 = sorted(L, key=by_name)
print(L2)

# 按照成绩排序
def by_score(t):
    return -t[1]
L2 = sorted(L, key=by_score)
print(L2)

# 一个简单的例子
# 每次调用都会返回一个新的函数，f1()和f2()调用结果互不影响
def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum
f = lazy_sum(1, 2, 3)
f()

# 仅读取x的值:
def inc():
    x = 0
    def fn():
        return x + 1
    return fn

f = inc()
print(f())

def inc():
    x = 0
    def fn():
        nonlocal x # 使得x为内函数局部变量
        x = x + 1
        return x
    return fn

f = inc()
print(f())

# 之前对map函数的利用
list(map(lambda x: x*x, [1,2,4,5]))

# 可以赋值给一个变量
f = lambda x: x*x
f(5)

# 作为一个函数返回
def build(x, y):
    return lambda: x * x + y * y
build(2,3)

def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

@log
def now():
    print('2015-3-25')

now()
# 当我们打印now函数的名称时候发现已经改变，因此需要修改这种写法
print(now.__name__)

import functools

def log(func):
    @functools.wraps(func)  # 添加本行语句保持now函数属性未发生修改
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

@log
def now():
    print('2015-3-25')
now()

print(now.__name__)

# 固定int()函数中base=2这个关键字参数
in2 = functools.partial(int, base=2)
in2('10')

# 将10作为*args输入参数左边
max2 = functools.partial(max, 10)
max2(1,2,3)

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

""" add some comments """

__author__ = 'Michael Liao'

import sys

def hello(name='tsh'):
    print(sys.path)
    print('hello %s' %name)

if __name__=='__main__':
    hello()

# 打印安装包路径
import sys
sys.path

## 定义一个类
class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def get_grade(self, score):
        if score > 90:
            return 'a'
        else:
            return 'b'

xiaomei = Student("xiaomei", 18)
print(xiaomei.age)
print(xiaomei.get_grade(85))
xiaomei.sex = 'female'  # 添加动态属性
print(xiaomei.sex)

## Python3已经默认继承了object对象
class Student(object):
    """不添加object"""
    name = "tsh"

class Person():
    """添加object"""
    name = "yyy"

if __name__ == '__main__':
    x = Student()
    print(dir(x))

    y = Person()
    print(dir(y))

## 定义一个类
class Student:
    def __init__(self, name, age):
        self.__name = name
        self.age = age

xiaomei = Student("xiaomei", 18)
print(xiaomei._Student__name)

class Student:
    def __init__(self, name, gender):
        self.name = name
        self.__gender = gender

    def get_gender(self):
        return self.__gender

    def set_gender(self, new_gender):
        self.__gender = new_gender

# 测试:
bart = Student('Bart', 'male')
if bart.get_gender() != 'male':
    print('测试失败!')
else:
    bart.set_gender('female')
    if bart.get_gender() != 'female':
        print('测试失败!')
    else:
        print('测试成功!')

class Animal:
    def run(slef):
        print("animal is running")

class Dog(Animal): # Dog类继承Animal类，没有run方法（默认添加了run方法）
    pass

class Cat(Animal): # Cat类继承Animal类，有run方法
    def run(slef):
        print("cat is running")

class Car(object): # Car类没有继承Animal类，有run方法
    def run(slef):
        print("Car is running")

class Stone(object):
    pass

def run_twice(animal): # Stone类没有继承Animal类，没有run方法
    animal.run()
    animal.run()

run_twice(Animal())
run_twice(Dog())
run_twice(Cat())
run_twice(Car())
run_twice(Stone())

cat = Cat()
print(isinstance(cat, Cat)) # 判断一个变量是否属于某一个类型
print(isinstance(cat, Animal)) # cat这个实例既属于Cat类，有属于Animal类

type(123) # 判断基本类型和

type('abc') == type(123)

## 判断一个函数是否是函数
import types

def fn():
    pass

print(type(fn)==types.FunctionType)
print(type(abs)==types.BuiltinFunctionType)
print(type(lambda x: x)==types.LambdaType)
print(type((x for x in range(10)))==types.GeneratorType)

isinstance(cat, Animal)

isinstance([1, 2, 3], (list, tuple)) # 判断视list还是tuple

## 获得str对象的所有属性和方法
print(dir('123'))

len('123') == '123'.__len__()

# 让自己的类存在len(object)方法
class MyDog(object):
    def __len__(self):
         return 100

dog = MyDog()
len(dog)

class MyObject(object):
    def __init__(self):
        self.x = 9
    def power(self):
        return self.x * self.x

obj = MyObject()
print(hasattr(obj, 'x')) # 有属性'x'吗？
print(setattr(obj, 'y', 19)) # 设置'y'属性为19
print(getattr(obj, 'y')) # 获取y属性
print(getattr(obj, 'z', 404)) # z属性不存在返回默认值得404

print(dir(obj))

# 直接定义类的属性
class Student:
    name = 'Student'

s = Student()
print(s.name) # 打印name属性，因为实例并没有name属性，所以会继续查找class的name属性
print(Student.name) # 打印类的name属性
s.name = 'Michael' # 给实例绑定name属性
print(s.name) # 由于实例属性优先级比类属性高，因此，它会屏蔽掉类的name属性
print(Student.name) # 但是类属性并未消失，用Student.name仍然可以访问
del s.name # 如果删除实例的name属性
print(s.name) # 再次调用s.name，由于实例的name属性没有找到，类的name属性就显示出来了

# 创建一个实例
class Student():
    pass

s = Student()
# 给实例绑定一个属性
s.name = 'Bob'

# 给实例添加一个方法
def set_age(self, age):
    self.age = age

from types import MethodType
s.set_age = MethodType(set_age, s)
s.set_age(25)
s.age

# 使用__slots__限制属性
class Student(object):
    __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称

s = Student()
s.score = 99

# 一般类添加属性
class Student(object):

    def get_score(self):
         return self._score

    def set_score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value

# 带有@property的类
class Student(object):

    @property
    def score(self):
        return self._score

    @score.setter
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value

# Python练习的一个例子
class Screen(object):

    @property
    def width(self):
        return self.__width

    @width.setter
    def width(self, value):
        self.__width = value

    @property
    def height(self):
        return self.__height

    @height.setter
    def height(self, value):
        self.__height = value

    @property
    def resolution(self):
        return self.width*self.height

# 测试:
s = Screen()
s.width = 1024
s.height = 768
print('resolution =', s.resolution)
if s.resolution == 786432:
    print('测试通过!')
else:
    print('测试失败!')

# 定义一些类
class Animal(object):
    pass

# 大类:
class Mammal(Animal):
    pass

class Bird(Animal):
    pass

# 各种动物:
class Dog(Mammal):
    pass

class Bat(Mammal):
    pass

class Parrot(Bird):
    pass

class Ostrich(Bird):
    pass

# 定义更小的类
class RunnableMixIn(object):
    def run(self):
        print('Running...')

class FlyableMixIn(object):
    def fly(self):
        print('Flying...')

class Dog(Mammal, RunnableMixIn):
    pass

# 定义__str__方法，可以返回包含实例属性的字符串
class Student(object):
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return 'Student object (name=%s)' % self.name
    __repr__ = __str__ # 确保不使用print也可以使用

s = Student('Michael')
s

# 添加__iter__方法返回一个可迭代对象
class Fib(object):
    def __init__(self):
        self.a, self.b = 0, 1 # 初始化两个计数器a，b

    def __iter__(self):
        return self # 实例本身就是迭代对象，故返回自己

    def __next__(self):
        self.a, self.b = self.b, self.a + self.b # 计算下一个值
        if self.a > 10: # 退出循环的条件
            raise StopIteration()
        return self.a # 返回下一个值

for n in Fib():
    print(n)

# 添加__getitem__方法，确保可以类似list一样索引
class Fib(object):
    def __getitem__(self, n):
        a, b = 1, 1
        for x in range(n):
            a, b = b, a + b
        return a

f = Fib()
f[3]

# 添加__getattr__方法，返回不存在的属性值
class Student(object):

    def __getattr__(self, attr):
        if attr=='age':
            return lambda: 25
        raise AttributeError('\'Student\' object has no attribute \'%s\'' % attr)

s = Student()
s.age()

# 添加__call__，调用实例自身方法
class Student():
    def __init__(self, name):
        self.name = name

    def __call__(self):
        print('My name is %s.' % self.name)

s = Student('Bob')
s()

# 使用Enum来实现枚举常量功能
from enum import Enum

Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May',
                       'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))

for name, member in Month.__members__.items():
    print(name, '=>', member, ',', member.value)

# 从Enum自定义类，@unique装饰器可以帮助我们检查保证没有重复值
from enum import Enum, unique

@unique
class Weekday(Enum):
    Sun = 0 # Sun的value被设定为0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6

# 访问自定义枚举类型
Weekday.Tue.value

Weekday.Mon

Weekday['Mon']

Weekday(1).name

# 使用type()动态创建一个类
def fn(self, name='world'):
    print('HELLO, %s ' %name)

Hello = type('Hello', (object,), dict(hello=fn))
h = Hello()
h.hello()

try:  # 先执行try部分
    print('try...')
    r = 10 / int('a')
    print('result:', r)
except ValueError as e:  # 多个except捕获不同错误类型，不写明类型的时候默认所有
    print('ValueError:', e)
except ZeroDivisionError as e:
    print('ZeroDivisionError:', e)
else: # 没有错误的时候执行这一部分
    print('no errors')
finally:  # 这部分始终被执行
    print('finally...')
print('END')

# UnicodeError是ValueError的一个子类，因此第二个except很难捕获到
def foo(s):
    return 10 / int(s)

try:
    foo('a')
except ValueError as e:
    print('ValueError')
except UnicodeError as e:
    print('UnicodeError')

import logging

def foo(s):
    return 10 / int(s)

def bar(s):
    return foo(s) * 2

def main():
    try:
        bar('0')
    except Exception as e:
        logging.exception(e)

main()
print('END')

# 自定义错误类型
class FooError(ValueError):
    pass

def foo(s):
    n = int(s)
    if n==0:
        raise FooError('invalid value: %s' % s)
    return 10 / n

foo('0')

"""
在这里，程序先捕捉到自定错误ValueError，但在bar()中又抛出这个错误，这里捕获这个错误的目的
只是记录一下错误，便于后续追踪，由于当前函数不知道如何处理此类错误，所以又将这个错误抛出到
当前，所以，最恰当的方式是继续往上抛，让顶层调用者去处理
"""
def foo(s):
    n = int(s)
    if n==0:
        raise ValueError('invalid value: %s' % s)
    return 10 / n

def bar():
    try:
        foo('0')
    except ValueError as e:
        print('ValueError!')
        raise

bar()

## 当表达式n!=0为false时候，后面代码抛出AssertionError: n is zero!
## 使用Python -0 err.py可以关闭assert
def foo(s):
    n = int(s)
    assert n != 0, 'n is zero!'
    return 10 / n

def main():
    foo('0')
main()

import logging

logging.basicConfig(level=logging.error)
s = '0'
n = int(s)
logging.info('n = %d' % n)
print(10 / n)

# 定义一个dict类
class Dict(dict):

    def __init__(self, **kw):
        super().__init__(**kw)

    def __getattr__(self, key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError(r"'Dict' object has no attribute '%s'" % key)

    def __setattr__(self, key, value):
        self[key] = value

# 引入Python自带的unittest模块测试
import unittest
# from mydict import Dict

class TestDict(unittest.TestCase):

    def test_init(self):
        d = Dict(a=1, b='test')
        self.assertEqual(d.a, 1)
        self.assertEqual(d.b, 'test')
        self.assertTrue(isinstance(d, dict))

    def test_key(self):
        d = Dict()
        d['key'] = 'value'
        self.assertEqual(d.key, 'value')

    def test_attr(self):
        d = Dict()
        d.key = 'value'
        self.assertTrue('key' in d)
        self.assertEqual(d['key'], 'value')

    def test_keyerror(self):
        d = Dict()
        with self.assertRaises(KeyError):
            value = d['empty']

    def test_attrerror(self):
        d = Dict()
        with self.assertRaises(AttributeError):
            value = d.empty

# 一次性读取
with open('test_IO.txt', 'r') as f:
    print(f.read())

# 每次读取两个字节
with open('test_IO.txt', 'r') as f:
    for n in range(10):
        print(f.read(2))

# 逐行读取
with open('test_IO.txt', 'r') as f:
    for line in f.readlines():
        print(line.strip()) # 把末尾的'\n'删掉

with open('test_IO.txt', 'a') as f:
    f.write('Hello, world!') # 主要原文件文件最后一行是否换行

# 在内存中初始化f，并使用文件类似操作进行读取
from io import StringIO
f = StringIO('hello,\nworld')
while True:
    s = f.readline()
    if s == '':
        break
    print(s.strip())

# 内存中写入BytestIO
from io import BytesIO

f = BytesIO()
f.write('中文'.encode('utf-8'))
print(f.getvalue())

# 初始化二进制数据流，并读取
f = BytesIO(b'\xe4\xb8\xad\xe6\x96\x87')
f.read()

# 查看当前目录的绝对路径
os.path.abspath('.')

# 创建一个test目录
os.mkdir('/home/jupyter_code/testdir')

# 删除一个目录
os.rmdir('/home/jupyter_code/testdir')

# 拼接路径
os.path.join('/home/jupyter_code','testdier')

# 拆分路径
os.path.split('/home/jupyter_code/maren.ipynb')

# 拆分拓展名
os.path.splitext('/home/jupyter_code/maren.ipynb')

# 列出所有目录
[x for x in os.listdir('.') if os.path.isdir(x)]

# 列出所有txt文件
[x for x in os.listdir('.') if os.path.splitext(x)[1] == '.txt']

d = {'name':'Vob',
    'age':12,
    'score':90}
import pickle
# 将变量d写入txt文件
with open('d.txt','wb') as f:
    pickle.dump(d, f)

# 将变量从磁盘读入到内存
with open('d.txt', 'rb') as f:
    pickle.load(f)

import json

# 使用json将序列化为字符串
my_dict = dict(name='tsh', age=24, job='student')
json.dumps(my_dict)

# 将变量my_dict保存为json文件
with open('my_dict.json', 'w') as f:
    json.dump(my_dict, f, indent=4)

# 将JSON文件保存为变量读入到内存中
with open('my_dict.json','r') as f:
    data = json.load(f)

# 使用__dict__序列化实例
import json

class Student(object):
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score

s = Student('Bob', 20, 88)
print(json.dumps(s, default=lambda obj: obj.__dict__))

# 反序列化实例
def dict2student(d):
    return Student(d['name'], d['age'], d['score'])

json_str = '{"age": 20, "score": 88, "name": "Bob"}'
print(json.loads(json_str, object_hook=dict2student))

# 下面的例子演示了启动一个子进程并等待其结束
from multiprocessing import Process
import os

# 子进程要执行的代码
def run_proc(name):
    print('Run child process %s (%s)...' % (name, os.getpid()))

if __name__=='__main__':
    print('Parent process %s.' % os.getpid())
    p = Process(target=run_proc, args=('test',))
    print('Child process will start.')
    p.start()
    p.join() # 等待子进程结束后再继续往下运行，通常用于进程间的同步
    print('Child process end.')

from multiprocessing import Pool
import os, time, random

def long_time_task(name):
    print('Run task %s (%s)...' % (name, os.getpid()))
    start = time.time()
    time.sleep(random.random() * 3)
    end = time.time()
    print('Task %s runs %0.2f seconds.' % (name, (end - start)))

if __name__=='__main__':
    print('Parent process %s.' % os.getpid())
    p = Pool(4)
    for i in range(5):
        p.apply_async(long_time_task, args=(i,))
    print('Waiting for all subprocesses done...')
    p.close() # 调用close()之后就不能继续添加新的Process
    print('hello')
    p.join() # Pool对象调用join()方法会等待所有子进程执行完毕
    print('All subprocesses done.')