微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

python 并行计算 pathos模块 简介

分类：Python作者：whatday原文地址

目录

pathos模块

1、pathos自身的多进程方法（pathos.multiprocessing.ProcessPool、pathos.multiprocessing.ProcessingPool、pathos.pools.ProcessPool）

2、映射multiprocess模块的多进程方法（pathos.multiprocessing.Pool）

3、映射pp模块的多进程方法1（pathos.pools.ParallelPool、pathos.pp.ParallelPool、pathos.pp.ParallelPythonPool、pathos.parallel.ParallelPythonPool、pathos.parallel.ParallelPool）

4、映射pp模块的多进程方法2（pathos.pp.pp模块）

5、映射python内置map函数的方法（pathos.serial.SerialPool、pathos.pools.SerialPool）

实例（pathos模块）

（1）pathos.multiprocessing.ProcessPool()，pipe方法

（2）pathos.multiprocessing.ProcessPool()，apipe方法

（3）pathos.multiprocessing.ProcessPool()，map方法

（4）pathos.multiprocessing.ProcessPool()，imap方法

（5）pathos.multiprocessing.ProcessPool()，uimap方法

（6）pathos.multiprocessing.ProcessPool()，amap方法

（7）pathos.pp.ParallelPool()，pipe方法

（8）pathos.pp.ParallelPool()，apipe方法

（9）pathos.pp.ParallelPool()，map方法

（10）pathos.pp.ParallelPool()，amap方法

（11）pathos.pp.ParallelPool()，imap方法

（12）pathos.pp.ParallelPool()，uimap方法

pathos模块

pathos是一个较为综合性的模块，既能多进程，也能多线程。其主要采用进程池/线程池方法。

pathos本身有一套进程池方法，同时也集成了multiprocess、pp模块的进程池方法。

1、pathos自身的多进程方法（pathos.multiprocessing.Processpool、pathos.multiprocessing.ProcessingPool、pathos.pools.Processpool）

（1）建立进程池

pathos.multiprocessing.Processpool(*args,**kwds) #建立pathos的进程池（pathos.multiprocessing.Processpool实例）。

pathos.multiprocessing.ProcessingPool(*args,**kwds) #同上。

pathos.pools.Processpool(*args,**kwds) #同上。

nodes：workers的数量。如果不指定nodes，则自动检测processors的数量（即ncpus）。
ncpus：worker processors的数量。
servers：worker servers的列表。
scheduler：相应的scheduler。
workdir：用于scratch calculations/files的$workdir。
scatter：如为True，表示采用scatter-gatter（默认为worker-pool）。
source：如为False，表示尽可能少使用TemporaryFiles。
timeout：等待scheduler返回值的时间。

同样也有几个进程池通用的方法：

XXX.close() #关闭进程池，关闭后不能往pool中增加新的子进程，然后可以调用join()函数等待已有子进程执行完毕。XXX为进程池。

XXX.join() #等待进程池中的子进程执行完毕。需在close()函数后调用。XXX为进程池。

def f(a,b = value):
    pass

pool = pathos.multiprocessing.Pool() 
pool.map(f,a_seq,b_seq)
pool.close()
pool.join()

（2）创建子进程

（a）单个子进程可通过pipe方法创建：

XXX.pipe(f,*args,**kwds) #采用阻塞方式（非并行）提交一个任务，阻塞直到返回结果为止。XXX为进程池实例。

XXX.apipe(f,**kwds) #异步（并行）提交一个任务到队列（queue）中，返回ApplyResult实例（其get方法可获得任务返回值，但get方法是阻塞的，应在所有子进程添加完后再调用）。XXX为进程池实例。

f(*args,**kwds)为子进程对应的活动。

（b）如果子进程有返回值，且返回值需要集中处理，则建议采用map方式（子进程活动允许多个参数）：

XXX.map(f,**kwds) #采用阻塞方式按顺序运行一批任务，返回结果组成的list。func(iterable1[i],iterable2[i],...)为子进程对应的活动。XXX为进程池实例。

XXX.amap(f,**kwds) #XXX.map()的异步（并行）版本，返回MapResult实例（其具有get()方法，获取结果组成的list）。XXX为进程池实例。

def f(a,b): #map方法允许多个参数
    pass

pool = pathos.multiprocessing.Pool() 
result = pool.map_async(f,(a0,a1,...),(b0,b1,...)).get()
pool.close()
pool.join()

（c）如果内存不够用，也可采用imap迭代器方式：

XXX.imap(f,**kwds) #XXX.map()的非阻塞、按顺序迭代器版本，返回迭代器实例。XXX为进程池实例。

XXX.uimap(f,**kwds) #XXX.imap()的无序版本（不会按照调用顺序返回，而是按照结束顺序返回），返回迭代器实例。XXX为进程池实例。

def f(a,b): 
    pass

pool = pathos.multiprocessing.Pool() 
result = pool.uimap(f,b_seq)
pool.close()
pool.join()

for item in result:
    pass

2、映射multiprocess模块的多进程方法（pathos.multiprocessing.Pool）

（1）建立进程池

pathos.multiprocessing.Pool(processes=None,initializer=None,initargs=(),maxtasksperchild=None,context=None) #建立multiprocess的进程池。

processes ：使用的工作进程的数量，如果processes是None那么使用 os.cpu_count()返回的数量。
initializer： 如果initializer不是None，那么每一个工作进程在开始的时候会调用initializer(*initargs)。
maxtasksperchild：工作进程退出之前可以完成的任务数，完成后用一个新的工作进程来替代原进程，来让闲置的资源被释放。maxtasksperchild默认是None，意味着只要Pool存在工作进程就会一直存活。
context: 用在制定工作进程启动时的上下文，一般使用 multiprocess.Pool() 或者一个context对象的Pool()方法来创建一个池，两种方法都适当的设置了context。

（2）创建子进程

该进程池对应的创建子进程方法与multiprocess.Pool()（也即multiprocessing.Pool()）完全相同。

3、映射pp模块的多进程方法1（pathos.pools.ParallelPool、pathos.pp.ParallelPool、pathos.pp.ParallelpythonPool、pathos.parallel.ParallelpythonPool、pathos.parallel.ParallelPool）

（1）建立进程池

pathos.pp.ParallelPool(*args,**kwds) #建立映射pp模块方法的进程池，返回pathos.parallel.ParallelPool实例。注意，建立的进程池的方法与pp模块完全不同。

pathos.pp.ParallelpythonPool(*args,**kwds) #等价pathos.pp.ParallelPool()。

pathos.pools.ParallelPool(*args,**kwds) #等价pathos.pp.ParallelPool()。

pathos.parallel.ParallelPool(*args,**kwds) #等价pathos.pp.ParallelPool()。

pathos.parallel.ParallelpythonPool(*args,**kwds) #等价pathos.pp.ParallelPool()。

nodes：workers的数量。如果不指定nodes，则自动检测processors的数量（即ncpus）。
ncpus：worker processors的数量。
servers：worker servers的列表。
scheduler：相应的scheduler。
workdir：用于scratch calculations/files的$workdir。
scatter：如为True，表示采用scatter-gatter（默认为worker-pool）。
source：如为False，表示尽可能少使用TemporaryFiles。
timeout：等待scheduler返回值的时间。

（2）创建子进程

该进程池对应的创建子进程方法与pathos.multiprocessing.Processpool()完全相同（与pp模块完全不同）。

注意，multiprocessing.Pipe()或multiprocess.Pipe()建立的管道对象无法传入子进程（可能是pickle错误）。但是，ParallelPool进程池中，子进程print函数可以直接输出到标准输出，因此也不必通过管道将信息传递到主进程了。但是，子进程print输出的格式经常出现异常，最好还是通过返回值在主进程输出。

而且，amap方法是个特例。amap方法中，如果子进程有print语句，会导致返回结果不对，只包含最后一个子进程返回值的tuple，而不是所有子进程的返回值组成完整list，原因暂不清楚。因此，amap方法中，子进程需要输出的内容只能通过返回值在主进程输出。

4、映射pp模块的多进程方法2（pathos.pp.pp模块）

该方法实质就是pp模块。

5、映射python内置map函数的方法（pathos.serial.SerialPool、pathos.pools.SerialPool）

该类方法实际是串行（非并行），不做具体介绍。

SerialPool建立的进程池实际只能用pipe、map、imap方法（均是阻塞的），不能使用apipe、amap、uimap方法。

实例（pathos模块）

（1）pathos.multiprocessing.Processpool()，pipe方法

import pathos
import multiprocess
import time

def f(x,conn,t0):
    ans = 1
    x0 = x
    t = time.time() - t0
    conn.send('factorial of %d: start@%.2fs' % (x0,t))
    while x > 1:
        ans *= x
        time.sleep(0.5)
        x -= 1
    t = time.time() - t0
    conn.send('factorial of %d: finish@%.2fs,res = %d' %(x0,t,ans))
    return ans

def main():
    res = []
    var = (4,8,12,20,16)
    p = pathos.multiprocessing.Processpool()
    p_conn,c_conn = multiprocess.Pipe()
    t0 = time.time()
    for i in var:
        res.append(p.pipe(f,i,c_conn,t0))

    print('output:')
    while p_conn.poll():
        print(p_conn.recv())
    t = time.time() - t0
    print('factorial of %s@%.2fs: %s' % (var,res))

if __name__ == '__main__':
    main()

结果：可以看出，所有子进程都是逐个执行的。

 output:
factorial of 4: start@1.11s
factorial of 4: finish@2.61s,res = 24
factorial of 8: start@2.61s
factorial of 8: finish@6.12s,res = 40320
factorial of 12: start@6.12s
factorial of 12: finish@11.62s,res = 479001600
factorial of 20: start@11.63s
factorial of 20: finish@21.13s,res = 2432902008176640000
factorial of 16: start@21.15s
factorial of 16: finish@28.65s,res = 20922789888000
factorial of (4,16)@28.73s: [24,40320,479001600,2432902008176640000,20922789888000]

（2）pathos.multiprocessing.Processpool()，apipe方法

import pathos
import multiprocess
import time

def f(x,c_conn = multiprocess.Pipe()
    t0 = time.time()
    for i in var:
        res.append(p.apipe(f,t0))
    for i in range(len(res)):
        res[i] = res[i].get()

    print('output:')
    while p_conn.poll():
        print(p_conn.recv())
    t = time.time() - t0
    print('factorial of %s@%.2fs: %s' % (var,res))

if __name__ == '__main__':
    main()

结果：

output:
factorial of 4: start@1.10s
factorial of 8: start@1.18s
factorial of 12: start@1.19s
factorial of 20: start@1.25s
factorial of 4: finish@2.60s,res = 24
factorial of 16: start@2.61s
factorial of 8: finish@4.69s,res = 40320
factorial of 12: finish@6.69s,res = 479001600
factorial of 16: finish@10.11s,res = 20922789888000
factorial of 20: finish@10.75s,res = 2432902008176640000
factorial of (4,16)@10.85s: [24,20922789888000]

（3）pathos.multiprocessing.Processpool()，map方法

注意，实例将multiprocessing.Pipe()创建的连接作为参数传递给子进程，pickle出错，改为multiprocess.Pipe()创建连接即可解决。

import pathos
import multiprocess
import time

def f(x,ans))
    return ans

def main():
    var = (4,c_conn = multiprocess.Pipe()
    t0 = time.time()
    conn_s = [c_conn] * len(var)
    t0_s = [t0] * len(var)
    res = p.map(f,var,conn_s,t0_s)

    print('output:')
    while p_conn.poll():
        print(p_conn.recv())
    t = time.time() - t0
    print('factorial of %s@%.2fs: %s' % (var,res))

if __name__ == '__main__':
    main()

结果：可以看出，第一批次4个子进程几乎同时开启；当一个子进程结束后，马上开启第5个子进程。

output:
factorial of 4: start@1.15s
factorial of 8: start@1.15s
factorial of 12: start@1.19s
factorial of 20: start@1.26s
factorial of 4: finish@2.65s,res = 24
factorial of 16: start@2.65s
factorial of 8: finish@4.66s,res = 40320
factorial of 12: finish@6.70s,res = 479001600
factorial of 16: finish@10.15s,res = 20922789888000
factorial of 20: finish@10.76s,16)@10.91s: [24,20922789888000]

（4）pathos.multiprocessing.Processpool()，imap方法

import pathos
import multiprocess
import time

def f(x,c_conn = multiprocess.Pipe()
    t0 = time.time()
    conn_s = [c_conn] * len(var)
    t0_s = [t0] * len(var)
    res = list(p.imap(f,t0_s))

    print('output:')
    while p_conn.poll():
        print(p_conn.recv())
    t = time.time() - t0
    print('factorial of %s@%.2fs: %s' % (var,res))

if __name__ == '__main__':
    main()

结果：可以看出，第一批次4个子进程几乎同时开启；当一个子进程结束后，马上开启第5个子进程。

output:
factorial of 4: start@1.27s
factorial of 8: start@1.29s
factorial of 12: start@1.30s
factorial of 20: start@1.38s
factorial of 4: finish@2.77s,res = 24
factorial of 16: start@2.77s
factorial of 8: finish@4.79s,res = 40320
factorial of 12: finish@6.81s,res = 479001600
factorial of 16: finish@10.27s,res = 20922789888000
factorial of 20: finish@10.89s,16)@11.01s: [24,20922789888000]

（5）pathos.multiprocessing.Processpool()，uimap方法

import pathos
import multiprocess
import time

def f(x,c_conn = multiprocess.Pipe()
    t0 = time.time()
    conn_s = [c_conn] * len(var)
    t0_s = [t0] * len(var)
    res = list(p.uimap(f,res))

if __name__ == '__main__':
    main()

结果：可以看出，第一批次4个子进程几乎同时开启；当一个子进程结束后，马上开启第5个子进程。而且，第5个进程的返回值排在第4个进程的返回值之前。

output:
factorial of 4: start@1.03s
factorial of 8: start@1.08s
factorial of 12: start@1.10s
factorial of 20: start@1.15s
factorial of 4: finish@2.53s,res = 24
factorial of 16: start@2.53s
factorial of 8: finish@4.58s,res = 40320
factorial of 12: finish@6.60s,res = 479001600
factorial of 16: finish@10.03s,res = 20922789888000
factorial of 20: finish@10.66s,16)@10.78s: [24,20922789888000,2432902008176640000]

（6）pathos.multiprocessing.Processpool()，amap方法

import pathos
import multiprocess
import time

def f(x,c_conn = multiprocess.Pipe()
    t0 = time.time()
    conn_s = [c_conn] * len(var)
    t0_s = [t0] * len(var)
    res = p.amap(f,t0_s).get()

    print('output:')
    while p_conn.poll():
        print(p_conn.recv())
    t = time.time() - t0
    print('factorial of %s@%.2fs: %s' % (var,res))

if __name__ == '__main__':
    main()

结果：可以看出，第一批次4个子进程几乎同时开启；当一个子进程结束后，马上开启第5个子进程。

output:
factorial of 4: start@1.04s
factorial of 8: start@1.07s
factorial of 12: start@1.12s
factorial of 20: start@1.13s
factorial of 4: finish@2.54s,res = 24
factorial of 16: start@2.54s
factorial of 8: finish@4.58s,res = 40320
factorial of 12: finish@6.62s,res = 479001600
factorial of 16: finish@10.04s,res = 20922789888000
factorial of 20: finish@10.64s,16)@10.76s: [24,20922789888000]

（7）pathos.pp.ParallelPool()，pipe方法

注意，multiprocessing.Pipe()或multiprocess.Pipe()产生的管道对象无法传入子进程（可能是pickle错误）。但是，pathos.pp.ParallelPool()进程池中，子进程print函数可以直接输出到标准输出，因此也不必通过管道将信息传递到主进程了。

import pathos
import time

def f(x,t0):
    ans = 1
    x0 = x
    t = time.time() - t0
    print('factorial of %d: start@%.2fs' % (x0,t))
    while x > 1:
        ans *= x
        time.sleep(0.5)
        x -= 1
    t = time.time() - t0
    print('factorial of %d: finish@%.2fs,16)
    p = pathos.pp.ParallelPool()
    t0 = time.time()
    for i in var:
        res.append(p.pipe(f,t0))
        
    print('output:')
    t = time.time() - t0
    print('factorial of %s@%.2fs: %s' % (var,res))

if __name__ == '__main__':
    main()

结果：可以看出，所有子进程都是逐个执行的。

factorial of 4: start@0.12s
factorial of 4: finish@1.62s,res = 24
factorial of 8: start@1.80s
factorial of 8: finish@5.30s,res = 40320
factorial of 12: start@5.46s
factorial of 12: finish@10.96s,res = 479001600
factorial of 20: start@11.16s
factorial of 20: finish@20.66s,res = 2432902008176640000
factorial of 16: start@20.94s
factorial of 16: finish@28.44s,res = 20922789888000
output:
factorial of (4,16)@28.67s: [24,20922789888000]

（8）pathos.pp.ParallelPool()，apipe方法

import pathos
import time

def f(x,16)
    p = pathos.pp.ParallelPool()
    t0 = time.time()
    for i in var:
        res.append(p.apipe(f,t0))
        
    print('output:')
    for i in range(len(res)):
        res[i] = res[i].get()
    t = time.time() - t0
    print('factorial of %s@%.2fs: %s' % (var,res))

if __name__ == '__main__':
    main()

结果：可以看出，第一批次4个子进程几乎同时开启；当一个子进程结束后，马上开启第5个子进程。

output:
factorial of 4: start@0.20s
factorial of 4: finish@1.70s,res = 24
 factorial of 8: start@0.21s
factorial of 8: finish@3.71s,res = 40320
 factorial of 12: start@0.13s
factorial of 12: finish@5.63s,res = 479001600
 factorial of 20: start@0.18s
factorial of 20: finish@9.68s,res = 2432902008176640000
factorial of 16: start@1.70s
factorial of 16: finish@9.20s,res = 20922789888000
 factorial of (4,16)@9.72s: [24,20922789888000]

（9）pathos.pp.ParallelPool()，map方法

import pathos
import time

def f(x,16)
    p = pathos.pp.ParallelPool()
    t0 = time.time()
    res= p.map(f,[t0] * 5)
        
    print('output:')
    t = time.time() - t0
    print('factorial of %s@%.2fs: %s' % (var,res))

if __name__ == '__main__':
    main()

结果：可以看出，所有子进程都是逐个执行的。

factorial of 4: start@0.14s
factorial of 4: finish@1.64s,res = 24
factorial of 8: start@1.74s
factorial of 8: finish@5.24s,res = 40320
factorial of 12: start@5.35s
factorial of 12: finish@10.85s,res = 479001600
factorial of 20: start@11.01s
factorial of 20: finish@20.51s,res = 2432902008176640000
factorial of 16: start@20.66s
factorial of 16: finish@28.16s,res = 20922789888000
 output:
factorial of (4,16)@28.51s: [24,20922789888000]

（10）pathos.pp.ParallelPool()，amap方法

注意：amap方法中，如果子进程有print语句，会导致返回结果是只包含最后一个子进程返回值的tuple，而不是所有子进程的返回值组成完整list，原因暂不清楚。因此，amap方法中，子进程需要输出的内容只能通过返回值在主进程输出。

import pathos
import time

def f(x,t0):
    ans = 1
    x0 = x
    t = time.time() - t0
    msg1 = 'factorial of %d: start@%.2fs' % (x0,t)
    while x > 1:
        ans *= x
        time.sleep(0.5)
        x -= 1
    t = time.time() - t0
    msg2 = 'factorial of %d: finish@%.2fs,ans)
    return (ans,msg1,msg2)

def main():
    var = (4,16)
    p = pathos.pp.ParallelPool()
    t0 = time.time()
    ret = p.amap(f,[t0] * 5).get()
    res = [item[0] for item in ret]
        
    print('output:')
    for item in ret:
        print(item[1])
        print(item[2])
    t = time.time() - t0
    print('factorial of %s@%.2fs: %s' % (var,res))

if __name__ == '__main__':
    main()

结果：可以看出，第一批次4个子进程几乎同时开启；当一个子进程结束后，马上开启第5个子进程。

output:
factorial of 4: start@0.16s
factorial of 4: finish@1.66s,res = 24
factorial of 8: start@0.18s
factorial of 8: finish@3.68s,res = 40320
factorial of 12: start@0.19s
factorial of 12: finish@5.69s,res = 479001600
factorial of 20: start@0.14s
factorial of 20: finish@9.64s,res = 2432902008176640000
factorial of 16: start@1.66s
factorial of 16: finish@9.16s,20922789888000]

（11）pathos.pp.ParallelPool()，imap方法

import pathos
import time

def f(x,16)
    p = pathos.pp.ParallelPool()
    t0 = time.time()
    ret = list(p.imap(f,[t0] * 5))
    res = [item[0] for item in ret]
        
    print('output:')
    for item in ret:
        print(item[1])
        print(item[2])
    t = time.time() - t0
    print('factorial of %s@%.2fs: %s' % (var,res))

if __name__ == '__main__':
    main()

结果：可以看出，所有子进程都是逐个执行的。

output:
factorial of 4: start@0.17s
factorial of 4: finish@1.67s,res = 24
factorial of 8: start@1.67s
factorial of 8: finish@5.17s,res = 40320
factorial of 12: start@5.17s
factorial of 12: finish@10.67s,res = 479001600
factorial of 20: start@10.67s
factorial of 20: finish@20.17s,res = 2432902008176640000
factorial of 16: start@20.17s
factorial of 16: finish@27.67s,16)@28.41s: [24,20922789888000]

（12）pathos.pp.ParallelPool()，uimap方法

import pathos
import time

def f(x,16)
    p = pathos.pp.ParallelPool()
    t0 = time.time()
    ret = list(p.uimap(f,res))

if __name__ == '__main__':
    main()

结果：可以看出，第一批次4个子进程几乎同时开启；当一个子进程结束后，马上开启第5个子进程。而且，第5个进程的返回值排在第4个进程的返回值之前。

output:
factorial of 4: start@0.26s
factorial of 4: finish@1.76s,res = 24
factorial of 8: start@0.29s
factorial of 8: finish@3.79s,res = 40320
factorial of 12: start@0.25s
factorial of 12: finish@5.75s,res = 479001600
factorial of 16: start@1.77s
factorial of 16: finish@9.28s,res = 20922789888000
factorial of 20: start@0.31s
factorial of 20: finish@9.81s,16)@10.24s: [24,2432902008176640000]

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

如何用django开发一个简易个人Blog
功能概要：（目前已实现功能）公共展示部分：1.网站首页展示已发布的博客记录，包括名称、摘要信息、发布日期、阅读量及评论数。2.首页文章列表可按照分类筛选。3.点击标题或阅读全文链接，进入博客阅读页面，展示文章标题、内容及评论内容。博客后台管理部分：（后台套用了一个叫做ACE的后台模板，改造成了dja
Python中的几种数据类型
大体上把Python中的数据类型分为如下几类： Number（数字） 包括int,long,float,complex String（字符串） 例如：hello,"hello",hello List（列表） 例如：[1,2,3],[1,2,3,[1,2,3],4] Diction
django开发个人简易Blog——构建项目结构
开发之前第一步，就是构造整个的项目结构。这就好比作一幅画，第一步就是描绘轮廓，有了轮廓，剩下的就是慢慢的填充细节。项目结构规划如下图：项目结构描述:本项目以fengzhengBlog为根目录。admin、blogapp是两个app目录,用于实现项目主要功能：包括模型定义、视图定义等css、js、im
Linux下安装Apache并以mod_wsgi方式部署django站点
源码编译方式安装Apache首先下载Apache源码压缩包，地址为http://mirror.bit.edu.cn/apache/httpd/继续下载apr和apr-util压缩包，地址为http://mirror.bit.edu.cn/apache/apr/下载pcre压缩包，地址为http://
django开发个人简易Blog—nginx+uwsgin+django1.6+mysql 部署到CentOS6.5
前面说完了此项目的创建及数据模型设计的过程。如果未看过，可以到这里查看，并且项目源码已经放大到github上,可以去这里下载。代码也已经部署到sina sea上，地址为http://fengzheng.sinaapp.com/先跳过视图展示及表单处理的部分，先介绍一下如何部署。标题中已经把部署环境介
Scrapy爬取自己的博客内容
python中常用的写爬虫的库有urllib2、requests,对于大多数比较简单的场景或者以学习为目的，可以用这两个库实现。这里有一篇我之前写过的用urllib2𫯪utifulSoup做的一个抓取百度音乐热门歌曲的例子，有兴趣可以看一下。本文介绍用Scrapy抓取我在博客园的博客列表，只抓
用python实现的百度音乐下载器-python-pyqt-改进版
之前写过一个用python实现的百度新歌榜、热歌榜下载器的博文，实现了百度新歌、热门歌曲的爬取与下载。但那个采用的是单线程，网络状况一般的情况下，扫描前100首歌的时间大概得到40来秒。而且用Pyqt做的界面，在下载的过程中进行窗口操作，会出现UI阻塞的现象。 前两天有时间调整了一下，做了几方面的改
Python:解决中文字符串问题
本人安装的是Python 2.7版本，由于编写程序的过程中会碰到中文字符串，但由于Python默认采用ASCII编码方式，所以对中文不支持。要解决此问题，必须设置当前编码方式为Unicode方式。默认ASCII编码方式对中文字符产生的异常为：UnicodeDecodeError: 'asci
Django集成百度富文本编辑器uEditor
UEditor是由百度web前端研发部开发所见即所得富文本web编辑器，具有轻量，可定制，注重用户体验等特点，开源基于MIT协议，允许自由使用和修改代码。首先从ueEditor官网下载最新版本的包，目前官网上提供了ASP、.NET、PHP、JSP版本的，django版本只有一个第三方个人开发的，但看
django开发个人简易Blog——数据模型
提到数据模型，一定要说一下MVC,MVC框架是现代web开发中最流行的开发框架，它将数据与业务逻辑分开，减小了应用之间的高度耦合。个人非常喜欢MVC开发框架，除了具有上述特性，它使得web开发变得非常灵活，在ASP.NET上表现的尤为强烈，传统的ASP.NET开发常常用到好多臃肿的服务器端控件，定制
苹果市值2025年有望达4万亿美元
pythonJavaScriptjavaHTMLreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-bootreact-native