import numpy
a = numpy.arange(10)
print(a) # [0 1 2 3 4 5 6 7 8 9] 看起来是个列表，实际不是
print([1,2,3]) # [1, 2, 3] 这才是列表

a = numpy.random.randint(4,10,size=(3,4,2))
print(a) # 第一纬度3个元素，第二纬度4个元素,第三纬度2个元素 随机数在最里面的纬度
# [
# [[4 5][5 5][5 7][9 6]]
# [[6 9][5 7][7 9][7 9]]
# [[8 7][8 7][7 6][8 6]]
# ]

x = numpy.zeros(5) # [0. 0. 0. 0. 0.] 默认是float
x = numpy.zeros((5,),dtype=int) # # [0 0 0 0 0]
x = numpy.zeros((2,2),dtype=str) #[['' '']['' '']]

x = numpy.ones((5,),dtype=int) # # [1 1 1 1 1]
x = numpy.ones((2,2),dtype=str) #[['1' '1']['1' '1']]

x = numpy.empty((5,),dtype=int) 
x = numpy.empty((2,2),dtype=str) 

a = numpy.arange(10)
b = a[2:7:1]
c = a[3:]

print(a[1])

a = numpy.arange(1,13)
print(a)
b = a.reshape(2,3,2) # 乘积需要等于元素个数
print(b)
c = b.ravel()
print(c)
d = c.flatten()
print(d)

from multiprocessing import Process,set_start_method
set_start_method('spawn',True) # 在vscode中运行时需要加上这个，否则要报错
#定义子进程代码
def run_proc():
    print('子进程运行中')

if __name__=='__main__':
    print('父进程运行')
    p=Process(target=run_proc)
    print('子进程将要执行')
    p.start()

from multiprocessing import Process,set_start_method
import os
from time import sleep

set_start_method('spawn',True)
#创建子进程代码
def run_proc(name,age,**kwargs):
    for i in range(5):
        print('子进程运行中，参数name：%s,age:%d'%(name,age))
        print('字典参数kwargs：',kwargs)
        sleep(0.5)

if __name__=='__main__':
    print('主进程开始运行')
    p=Process(target=run_proc,args=('张山',38),kwargs={'book1':'test1','chuban':'xin'})
    print('子进程将要执行')
    p.start()

from multiprocessing import Process,set_start_method
from time import sleep

set_start_method('spawn',True)
def worker(interval):
    print("work start")
    sleep(interval)
    print("work end")

if __name__ == "__main__":
    p = Process(target = worker, args = (10,))
    p.start()
    print('等待进程p终止')
    p.join(3) # 如果子进程未结束 程序已经结束，子程序还是会继续执行的
    print("主进程结束!")
    '''
    等待进程p终止
    work start
    主进程结束!
    work end
    '''

from multiprocessing import Process,set_start_method
from time import sleep

set_start_method('spawn',True)
#创建进程调用函数
def work1(interval):
    print('work1')
    sleep(interval)
    print('end work1')
def work2(interval):
    print('work2')
    sleep(interval)
    print('end work2')
def work3(interval):
    print('work3')
    sleep(interval)
    print('end work3')
if __name__=='__main__':
    #创建进程对象
    p1=multiprocessing.Process(target=work1,args=(4,))
    p2=multiprocessing.Process(target=work2,args=(3,))
    p3=multiprocessing.Process(target=work3,args=(2,))
    #启动进程
    p1.start()
    p2.start()
    p3.start()
    p1.join()
    print("p1 join")
    p2.join()
    print("p2 join")
    p3.join()
    print("p3 join")
    print('主进程结束')

from multiprocessing import Process
import time
#定义线程类
class MyProcess(Process):
    def __init__(self,interval):
        Process.__init__(self)
        self.interval=interval
    def run(self): # 一定要重新这个方法
        print('子进程开始执行的时间:{}'.format(time.ctime()))
        time.sleep(self.interval)
        print('子进程结束的时间:{}'.format(time.ctime()))

if __name__=='__main__':
    #创建进程
    p=MyProcess(3)
    #启动进程
    p.start()
    p.join()
    print('主进程结束')

from multiprocessing import Process,set_start_method,Pool

import time,os

set_start_method('spawn',True)

def func(msg):
    print("start:", msg)
    time.sleep(3)
    print("end：",msg)

if __name__ == "__main__":
    pool = multiprocessing.Pool(processes = 3)
    for i in range(5):
        msg = "hello %d" %(i)
        #维持执行的进程总数为processes，当一个进程执行完毕后会添加新的进程进去
        pool.apply_async(func, (msg, ))

    pool.close() #进程池关闭之后不再接收新的请求
    # 调用join之前，先调用close函数，否则会出错。
    # 执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束
    pool.join() # 如果不等待，主程序会提前结束，未完的子程序会报错
    print('主进程结束')

from multiprocessing import Process,set_start_method,Pool

import time,os

set_start_method('spawn',True)

def func(msg):
    print("start:", msg)
    time.sleep(3)
    print("end",msg)

if __name__ == "__main__":
    pool = multiprocessing.Pool(processes = 3)
    for i in range(5):
        msg = "hello %d" %(i)
        #维持执行的进程总数为processes，当一个进程执行完毕后会添加新的进程进去
        pool.apply(func, (msg, ))

    pool.close()
    #调用join之前，先调用close函数，否则会出错。
    # 执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束
    pool.join()

from multiprocessing import Process
num=1
def work1():
    global num
    num+=5
    print('子进程1运行，num:',num)

def work2():
    global num
    num += 10
    print('子进程2运行，num：',num)

if __name__=='__main__':
    print('父进程开始运行')
    p1=Process(target=work1)
    p2=Process(target=work2)
    p1.start()
    p2.start()
    p1.join()
    p2.join()
'''
子进程1运行，num: 6
子进程2运行，num: 11
'''

from multiprocessing import Queue
q=Queue(3)
q.put('消息1')
q.put('消息2')
print('消息队列是否已满：',q.full())
q.put('消息3')
print('消息队列是否已满：',q.full())

# q.put('消息4')因为消息队列已满，需要直接写入需要等待，如果超时会抛出异常，
# 所以写入时候需判断，消息队列是否已满
if not q.full():
    q.put('消息4')

#同理读取消息时，先判断消息队列是否为空，再读取
# qsize在MacOS上无法运行
# Raises NotImplementedError on Mac OSX because of broken sem_getvalue()
#return self._maxsize – # self._sem._semlock._get_value()

# 所以 不能这样用
#for i in range(q.qsize()):
#    print(q.get())

while(not q.empty()):
    print(q.get())

    

from multiprocessing import *
import time
def write(q):
    #将列表中的元素写入队列中
    for i in ["a","b","c"]:
        print('开始写入值%s' % i)
        q.put(i)
        time.sleep(1)

#读取
def read(q):
    print('开始读取')
    while True:
        if not q.empty():
            print('读取到:',q.get())
            time.sleep(1)
        else:
            break
if __name__=='__main__':
    #创建队列
    q=Queue()
    #创建写入进程
    pw=Process(target=write,args=(q,))
    pr=Process(target=read,args=(q,))
    #启动进程
    pw.start()
    pw.join()
    pr.start() # 注意：测试一下将这个放到pw.join()之前
    pr.join()

from multiprocessing import Manager,Pool
import time
def write(q):
    #将列表中的元素写入队列中
    for i in ["a","b","c"]:
        print('开始写入值%s' % i)
        q.put(i)
        time.sleep(1)

#读取
def read(q):
    print('开始读取')
    while True:
        if not q.empty():
            print('读取到:',q.get())
            time.sleep(1)
        else:
            break
if __name__=='__main__':
    #创建队列
    q=Manager().Queue()
    #创建进程池
    p=Pool(3)
    #使用阻塞模式创建进程
    p.apply(write,(q,))
    p.apply(read,(q,)) # 如果使用异步，需要修改read保证读取
    p.close() # 不要忘了关闭
    p.join()