python学习笔记(多任务)

最新推荐文章于 2024-11-13 17:26:18 发布
最新推荐文章于 2024-11-13 17:26:18 发布
阅读量423 收藏 1
点赞数
分类专栏： 学习记录 文章标签： python 多线程 多进程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leeyns/article/details/107229357
版权

多任务

多任务有并发和并行之分。

并发:假的多任务,多个任务共用一个核
并行:正的多任务,一个核处理一个程序

线程

python中线程有两种创建方法

使用threading.Thread 创建

如果不使用线程，进行两个任务，一定是要等待任务1完成后才会执行任务2。

import time

def Thread1():
    for i in range(5):
        print("----- Thread1 ------")
        time.sleep(0.1)


def Thread2():
    for i in range(5):
        print("***** Thread2 *****")
        time.sleep(0.1)


def main():
    Thread1()
    Thread2()


if __name__ == "__main__":
    main()

----- Thread1 ------
----- Thread1 ------
----- Thread1 ------
----- Thread1 ------
----- Thread1 ------
***** Thread2 *****
***** Thread2 *****
***** Thread2 *****
***** Thread2 *****
***** Thread2 *****

如果使用了线程那么在任务1执行时，系统会自动调用资源使得资源利用率提高。

import time
import threading

def Thread1():
    for i in range(5):
        print("----- Thread1 ------")
        time.sleep(0.1)


def Thread2():
    for i in range(5):
        print("***** Thread2 *****")
        time.sleep(0.1)


def main():
    t1 = threading.Thread(target=Thread1)
    t2 = threading.Thread(target=Thread2)

    t1.start()
    t2.start()


if __name__ == "__main__":

    main()

----- Thread1 ------
***** Thread2 *****
----- Thread1 ------
***** Thread2 *****
***** Thread2 *****
----- Thread1 ------
***** Thread2 *****
----- Thread1 ------
***** Thread2 *****
----- Thread1 ------

通过创建threading.Tread的子类

import threading
import time


class MyThread(threading.Thread):
    def run(self):
        for i in range(3):
            time.sleep(1)
            msg = "thread" + str(i)  
            print(msg)


if __name__ == '__main__':
    t = MyThread()
    t.start()

通过创建threading.Tread的子类创建线程，我们只需要将执行的函数写入类的run方法中，在开始线程时，仍然使用start()方法。
子类必须要集成threading.Thread父类

查看线程数

可以通过threading.enumerate()来查看当前的线程数。

线程共享全局变量

在线程中，全局变量是共享的，每个线程调用并修改全局变量在其他线程中都会有体现。

import threading

g_num = 100

def test1():
    global g_num
    g_num += 100
    print("---- test1 %d----" % g_num)


def test2():
    global g_num
    g_num +=100
    print("---- test2 %d----" % g_num)


def main():
    t1 = threading.Thread(target=test1)
    t2 = threading.Thread(target=test1)
    t1.start()
    t2.start()


if __name__ == "__main__":
    main()

---- test1 200----
---- test1 300----

可以看到对于全局变量，不同线程的操作都是有效的。

对全局变量的操作

在一个函数中对全局变量的修改的时候，是否需要使用global进行说明，要看是否对全局变量的指向进行了修改。

如果修改了指向，即让全局变量指向了一个新的地方，那么必须要用global，如果仅仅修改了指向的空间中的数据，则不需要使用global。

>>> num = 100
>>> nums = [11,22]
>>> def test():
...     global num
...     num += 100
... 
>>> def test2():
...     nums.append(33)
... 
>>> print(num)
100
>>> print(nums)
[11, 22]

>>> test()
>>> test2()
>>> num
200
>>> nums
[11, 22, 33]

共享全局变量出现的问题

在执行任务复杂时，可能因为系统资源分配问题，在一个操作没有完成的时候系统就将资源分配给另一个线程导致最终的数据出错。

import threading
import time

g_num = 0


def work1(num):
    global g_num
    for i in range(num):
        g_num += 1
    print("----in work1, g_num is %d---" % g_num)


def work2(num):
    global g_num
    for i in range(num):
        g_num += 1
    print("----in work2, g_num is %d---" % g_num)


print("---线程创建之前g_num is %d---" % g_num)

t1 = threading.Thread(target=work1, args=(1000000, ))
t1.start()

t2 = threading.Thread(target=work2, args=(1000000, ))
t2.start()

while len(threading.enumerate()) != 1:
    time.sleep(1)

print("2个线程对同一个全局变量操作之后的最终结果是:%s" % g_num)

threading.Thread() 线程指定的函数有参数，通过args=()传递参数，传递的内容是元组。(xx,xx,)

Liyingshu:网络编程 mac$ /usr/local/bin/python3 /Users/mac/Desktop/网络编程/web服务器/多任务/全局变量问题.py
—线程创建之前g_num is 0—
----in work1, g_num is 1230221—
----in work2, g_num is 1327526—
2个线程对同一个全局变量操作之后的最终结果是:1327526
Liyingshu:网络编程 mac$ /usr/local/bin/python3 /Users/mac/Desktop/网络编程/web服务器/多任务/全局变量问题.py
—线程创建之前g_num is 0—
----in work1, g_num is 1334166—
----in work2, g_num is 1483024—
2个线程对同一个全局变量操作之后的最终结果是:1483024

可以看到两次执行的结果不一样，这就是线程共享全局变量出现的问题。如果要避免这个问题的发生，我们需要添加互斥锁，即在资源共享时，一个线程操作的同时另外的线程只有等待上一个操作完成后才能操作。

互斥锁

threading模块中定义了Lock类，可以方便的处理锁定：

# 创建锁
mutex = threading.Lock()

# 锁定
mutex.acquire()

# 释放
mutex.release()

上一个例子里如果添加了互斥锁就不会出现数据错误的情况了。

import threading
import time

g_num = 0


def test1(num):
    global g_num
    for i in range(num):
        mutex.acquire()  # 上锁
        g_num += 1
        mutex.release()  # 解锁

    print("---test1---g_num=%d" % g_num)


def test2(num):
    global g_num
    for i in range(num):
        mutex.acquire()  # 上锁
        g_num += 1
        mutex.release()  # 解锁

    print("---test2---g_num=%d" % g_num)


# 创建一个互斥锁
# 默认是未上锁的状态
mutex = threading.Lock()

# 创建2个线程，让他们各自对g_num加1000000次
p1 = threading.Thread(target=test1, args=(1000000, ))
p1.start()

p2 = threading.Thread(target=test2, args=(1000000, ))
p2.start()

# 等待计算完成
while len(threading.enumerate()) != 1:
    time.sleep(1)

print("2个线程对同一个全局变量操作之后的最终结果是:%s" % g_num)

—test2—g_num=1971926
—test1—g_num=2000000
2个线程对同一个全局变量操作之后的最终结果是:2000000

进程

进程：一个程序运行起来后，代码+用到的资源 称之为进程，它是操作系统分配资源的基本单元。

创建进程

创建进程要使用multiprocessing模块。

Process([group [, target [, name [, args [, kwargs]]]]])
target：如果传递了函数的引用，这个子进程就执行这里的代码
args：给target指定的函数传递的参数，以元组的方式传递
kwargs：给target指定的函数传递命名参数
name：给进程设定一个名字，可以不设定
group：指定进程组，大多数情况下用不到

Process创建的实例对象的常用方法：
start()：启动子进程实例（创建子进程）
is_alive()：判断进程子进程是否还在活着
join([timeout])：是否等待子进程执行结束，或等待多少秒
terminate()：不管任务是否完成，立即终止子进程

Process创建的实例对象的常用属性：
name：当前进程的别名，默认为Process-N，N为从1开始递增的整数
pid：当前进程的pid（进程号）

import multiprocessing
import time

def work1():
    while True:
        print("---this is work1---")
        time.sleep(0.5)


def main():
    p1 = multiprocessing.Process(target=work1)
    p1.start()
    while True:
        print("---this is main---")
        time.sleep(0.5)

if __name__ == "__main__":
    main()

获取进程的pid

通过导入os模块，使用os.getpid()方法来获取进程的pid。

import multiprocessing
import time
import os


def work1():
    print('子进程运行中，pid=%d...' % os.getpid())  # os.getpid获取当前进程的进程号
    while True:
        print("---this is work1---")
        time.sleep(0.5)


def main():
    print('父进程pid: %d' % os.getpid())  # os.getpid获取当前进程的进程号
    p1 = multiprocessing.Process(target=work1)
    p1.start()
    while True:
        print("---this is main---")
        time.sleep(0.5)


if __name__ == "__main__":
    main()

父进程pid: 3666
—this is main—
子进程运行中，pid=3668…
—this is work1—
—this is main—
—this is work1—
—this is main—
—this is work1—
—this is main—

进程传参

import multiprocessing
import time


def work1(name,age,*args,**kwargs):
    print("name: %s, age:%d" % (name,age))
    print(args)
    print(kwargs)



def main():
    p1 = multiprocessing.Process(target=work1,args=("lee",18,20,12,{1234,123}),kwargs={'y':11})
    p1.start()


if __name__ == "__main__":
    main()

name: lee, age:18
(20, 12, {1234, 123})
{‘y’: 11}

超出指定的参数个数时，其他的参数都存在一个元组中，例子中的20,12,{1234,123}，列表则用kwargs来赋值。

进程不共享全局变量

在进程中，对全局变量的修改不共享。

from multiprocessing import Process
import os
import time

nums = [11, 22]


def work1():
    print("process1 pid=%d ,nums=%s" % (os.getpid(), nums))
    for i in range(5):
        nums.append(i)
        time.sleep(1)
        print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))


def work2():
    print("in process2 pid=%d ,nums=%s" % (os.getpid(), nums))


if __name__ == '__main__':
    p1 = Process(target=work1)
    p1.start()
    p1.join()

    p2 = Process(target=work2)
    p2.start()

process1 pid=3995 ,nums=[11, 22]
in process1 pid=3995 ,nums=[11, 22, 0]
in process1 pid=3995 ,nums=[11, 22, 0, 1]
in process1 pid=3995 ,nums=[11, 22, 0, 1, 2]
in process1 pid=3995 ,nums=[11, 22, 0, 1, 2, 3]
in process1 pid=3995 ,nums=[11, 22, 0, 1, 2, 3, 4]
in process2 pid=3997 ,nums=[11, 22]

进程间的通信

进程间不能共享全局变量，有时我们需要在进程中进行通信，模块中提供了Queue方法进行进程间的通信。

初始化Queue(num)对象时（例如：q=Queue()），如果没有指定num，那么就代表可接受的消息数量没有上限（直到内存的尽头）；

Queue.qsize()：返回当前队列包含的消息数量，在mac os无法使用 ；

Queue.empty()：如果队列为空，返回True，反之False ；

Queue.full()：如果队列满了，返回True,反之False；

Queue.get([block[, timeout]])：获取队列中的一条消息，然后将其从列队中移除，block默认值为True；

1）block表示，如果消息队列为空是否堵塞等待，timeout表示如果堵塞了，系统等待多少秒，超过了这个时间系统叫抛出"Quere,Empty"异常。

2）如果block值为False，消息列队如果为空，则会立刻抛出"Queue.Empty"异常；

Queue.get_nowait()：相当Queue.get(False)；

Queue.put(item,[block[, timeout]])：将item消息写入队列，block默认值为True；

1）block表示，如果消息队列为已经满了，没有空间写入了，timeout表示如果堵塞了，系统等待多少秒，超过了这个时间系统叫抛出"Quere,Empty"异常。

2）如果block值为False，消息列队如果没有空间可写入，则会立刻抛出"Queue.Full"异常；

Queue.put_nowait(item)：相当Queue.put(item, False)；

from multiprocessing import Process, Queue
import os, time, random


# 写数据进程执行的代码:
def write(q):
    for value in ['A', 'B', 'C']:
        print('Put %s to queue...' % value)
        q.put(value)
        time.sleep(random.random())


# 读数据进程执行的代码:
def read(q):
    while True:
        if not q.empty():
            value = q.get(True)
            print('Get %s from queue.' % value)
            time.sleep(random.random())
        else:
            break


if __name__ == '__main__':
    # 父进程创建Queue，并传给各个子进程：
    q = Queue()
    pw = Process(target=write, args=(q, ))
    pr = Process(target=read, args=(q, ))
    # 启动子进程pw，写入:
    pw.start()
    # 等待pw结束:
    pw.join()
    # 启动子进程pr，读取:
    pr.start()
    pr.join()
    # pr进程里是死循环，无法等待其结束，只能强行终止:
    print('')
    print('所有数据都写入并且读完')

Put A to queue…
Put B to queue…
Put C to queue…
Get A from queue.
Get B from queue.
Get C from queue.

进程池

apply_async(func[, args[, kwds]])：使用非阻塞方式调用func（并行执行，堵塞方式必须等待上一个进程退出才能执行下一个进程），args为传递给func的参数列表，kwds为传递给func的关键字参数列表；
close()：关闭Pool，使其不再接受新的任务；
terminate()：不管任务是否完成，立即终止；
join()：主进程阻塞，等待子进程的退出， 必须在close或terminate之后使用；

初始化Pool时，可以指定一个最大进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到指定的最大值，那么该请求就会等待，直到池中有进程结束，才会用之前的进程来执行新的任务。

from multiprocessing import Pool
import os, time, random


def worker(msg):
    t_start = time.time()
    print("%s开始执行,进程号为%d" % (msg, os.getpid()))
    # random.random()随机生成0~1之间的浮点数
    time.sleep(random.random() * 2)
    t_stop = time.time()
    print(msg, "执行完毕，耗时%0.2f" % (t_stop - t_start))


po = Pool(3)  # 定义一个进程池，最大进程数3
for i in range(0, 10):
    # Pool().apply_async(要调用的目标,(传递给目标的参数元祖,))
    # 每次循环将会用空闲出来的子进程去调用目标
    po.apply_async(worker, (i, ))

print("----start----")
po.close()  # 关闭进程池，关闭后po不再接收新的请求
po.join()  # 等待po中所有子进程执行完成，必须放在close语句之后
print("-----end-----")

----start----
1开始执行,进程号为5628
0开始执行,进程号为5627
2开始执行,进程号为5629
0 执行完毕，耗时0.67
3开始执行,进程号为5627
2 执行完毕，耗时0.69
4开始执行,进程号为5629
4 执行完毕，耗时0.10
5开始执行,进程号为5629
5 执行完毕，耗时0.62
6开始执行,进程号为5629
1 执行完毕，耗时1.68
7开始执行,进程号为5628
7 执行完毕，耗时0.15
8开始执行,进程号为5628
6 执行完毕，耗时0.95
9开始执行,进程号为5629
9 执行完毕，耗时0.01
3 执行完毕，耗时1.78
8 执行完毕，耗时1.92
-----end-----

进程池内的Queue通信

如果要使用Pool创建进程，就需要使用multiprocessing.Manager()中的Queue()，而不是multiprocessing.Queue()

from multiprocessing import Manager, Pool
import os, time, random


def reader(q):
    print("reader启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
    for i in range(q.qsize()):
        print("reader从Queue获取到消息：%s" % q.get(True))


def writer(q):
    print("writer启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
    for i in "itcast":
        q.put(i)


if __name__ == "__main__":
    print("(%s) start" % os.getpid())
    q = Manager().Queue()  # 使用Manager中的Queue
    po = Pool()
    po.apply_async(writer, (q, ))

    time.sleep(1)  # 先让上面的任务向Queue存入数据，然后再让下面的任务开始从中取数据

    po.apply_async(reader, (q, ))
    po.close()
    po.join()
    print("(%s) End" % os.getpid())

(4866) start
writer启动(4868),父进程为(4866)
reader启动(4869),父进程为(4866)
reader从Queue获取到消息：i
reader从Queue获取到消息：t
reader从Queue获取到消息：c
reader从Queue获取到消息：a
reader从Queue获取到消息：s
reader从Queue获取到消息：t
(4866) End

协程

协程自带cpu上下文，在cpu处理耗时操作，可以从一个协程切换到另一个协程，yield可以实现它。python自带两个函数，greenlet和gevent可以实现协程。

greenlet

import greenlet
import time


def work1():
    while True:
        print("---1--")
        gr2.switch()
        time.sleep(1)


def work2():
    while True:
        print("---2--")
        gr1.switch()
        time.sleep(1)


gr1 = greenlet.greenlet(work1)
gr2 = greenlet.greenlet(work2)

gr1.switch()

—1–
—2–
—1–
—2–
—1–
—2–
—1–
—2–
—1–
—2–
—1–
—2–
—1–
—2–
—1–
—2–
—1–

通过switch方法手动切换协程，python还有gevent函数，可以实现自动切换协程。

gevent

通过gevent.spawn(target, item)创建协程，通过join()来执行协程，也可以使用joinall()执行多个协程。

from gevent import monkey
import gevent
import random
import time

# 有耗时操作时需要
monkey.patch_all()  # 将程序中用到的耗时操作的代码，换为gevent中自己实现的模块

def work1(coroutine_num):
    for i in range(10):
        print(coroutine_num, i)
        time.sleep(random.random())


def work2(coroutine_num):
    for i in range(15):
        print(coroutine_num, i)
        time.sleep(random.random())

gr1 = gevent.spawn(work1, gevent.getcurrent())
gr2 = gevent.spawn(work2, gevent.getcurrent())

gr1.join()
gr2.join()

# gevent.joinall([
#     gevent.spawn(work1, gevent.getcurrent()),
#     gevent.spawn(work2, gevent.getcurrent())
# ])

<greenlet.greenlet object at 0x7faab63664a0> 0
<greenlet.greenlet object at 0x7faab63664a0> 0
<greenlet.greenlet object at 0x7faab63664a0> 1
<greenlet.greenlet object at 0x7faab63664a0> 2
<greenlet.greenlet object at 0x7faab63664a0> 1
<greenlet.greenlet object at 0x7faab63664a0> 2
<greenlet.greenlet object at 0x7faab63664a0> 3
<greenlet.greenlet object at 0x7faab63664a0> 4
<greenlet.greenlet object at 0x7faab63664a0> 3
<greenlet.greenlet object at 0x7faab63664a0> 4
<greenlet.greenlet object at 0x7faab63664a0> 5
<greenlet.greenlet object at 0x7faab63664a0> 5
<greenlet.greenlet object at 0x7faab63664a0> 6
<greenlet.greenlet object at 0x7faab63664a0> 6
<greenlet.greenlet object at 0x7faab63664a0> 7
<greenlet.greenlet object at 0x7faab63664a0> 7
<greenlet.greenlet object at 0x7faab63664a0> 8
<greenlet.greenlet object at 0x7faab63664a0> 9
<greenlet.greenlet object at 0x7faab63664a0> 8
<greenlet.greenlet object at 0x7faab63664a0> 9
<greenlet.greenlet object at 0x7faab63664a0> 10
<greenlet.greenlet object at 0x7faab63664a0> 11
<greenlet.greenlet object at 0x7faab63664a0> 12
<greenlet.greenlet object at 0x7faab63664a0> 13
<greenlet.greenlet object at 0x7faab63664a0> 14

gevent中的延时是gevent.sleep()，我们需要打补丁来避免麻烦，monkey.patch_all().

leeyns
关注
专栏目录
python学习笔记之多进程
12-17
在现代操作系统中，如Windows、Linux和macOS，都支持多任务，即同一时间可以处理多个进程。每个进程都有自己的独立内存空间，它们之间通过特定机制（如信号量、管道或共享内存）进行通信。当我们在电脑上同时运行...
flask_apscheduler调用api接口时报错Either work inside a view function or push an application context
qq_42392337的博客
11-03 321
在使用flask_apscheduler调用内置api `/scheduler/jobs` 添加job任务接口时，报错`No application found. Either work inside a view function or push an application context.`
python协程
cdknight_happy的专栏
01-15 274
本文深度参考自廖雪峰老师的网站：https://www.liaoxuefeng.com/wiki/1016959663602400/1017968846697824 1 协程 协程(coroutine)的调用类似于子函数，即在函数A的执行过程中去执行子函数B，B执行完成后继续执行A。但使用协程实现的代码没有明显的函数调用。 协程是用同一个线程在不同的函数间切换，随时中断一个函数的执行去执行另一个函数。其执行过程类似于下述方式： def A(): print('1') print('2')
【专题】python中的协程库—greenlet和gevent
qq_36581961的博客
12-25 808
Python 的协程库 greenlet 和 gevent
Flask系列四
python之程的博客
06-29 443
阅读实际使用的开源项目如flask，对于提高编程能力有巨大好处。flask是实现网站功能，使用数据库的一个编程框架，已有中文出版有关书籍介绍。本系列讲座涉及的是非常精彩的The Flask Mega-Tutorial，开始于2017年12月6日开始，结束于2018年5月结束，每周一课。    对于一个不太大，但足够复杂的app的代理current_app的实现方法，本系列讲座进行彻底分析，分析过程...
Python使用gevent实现协程
weixin_43790276的博客
06-08 2647
Python使用gevent实现协程 Python中多任务的实现可以使用进程和线程，也可以使用协程。 一、协程介绍 协程，又称微线程。英文名Coroutine。协程是Python语言中所特有的，在其他语言中没有。 协程是python中另外一种实现多任务的方式，比线程更小、占用更小执行单元（理解为需要的资源）。 在一个线程中的某个函数，可以在任何地方保存当前函数的一些临时变量等信息，然后切...
Python学习笔记(干货) 中文PDF完整版.pdf
05-23
这份"Python学习笔记"涵盖了从环境搭建到基础语法，再到数据类型和控制结构等关键知识点，旨在为初学者提供全面的学习指导。 首先，1.1章节介绍了Python的基础，包括Python的起源和历史。Python是由Guido van ...
Python学习笔记 .pdf
12-21
这篇“Python学习笔记”详细介绍了Python的基本概念、语法和编程技巧。 首先，第一章介绍了编程的基础知识，包括程序的概念。程序是按照特定规则编写的指令集合，用于控制计算机执行特定任务。调试是找出并修复程序...
python学习笔记附带源码及实战
03-10
【Python学习笔记】 Python是一种高级编程语言，以其简洁明了的语法和强大的功能而闻名。这份学习笔记涵盖了从基础到高级的全方位Python知识，旨在帮助初学者快速掌握编程技能并进行实际项目开发。 【源码】 源码是...
Python协程-gevent
shifengboy的博客
08-05 845
gevent greenlet已经实现了协程，但是这个需要人工切换，是不是觉得太麻烦了，不要捉急，python还有一个比greenlet更强大的并且能够自动切换任务的模块gevent 其原理是当一个greenlet遇到IO(指的是input output 输入输出，比如网络、文件操作等)操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行。 ...
python中的装饰器，继承与抽象类
turned的博客
02-20 1367
装饰器： 装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。 继承： 在OOP程序设计中，当我们定义一个class的时候，可以...
ks8 本地化部署 F5-TTS
陈锐的技术笔记
11-13 544
此外，F5-TTS 还创新性地引入了推理时的 Sway Sampling 策略，这一策略可以在推理阶段优先处理早期的流步骤，从而提高生成语音与输入文本的对齐效果。在 LibriSpeech-PC 数据集上，该模型的字错误率（WER）达到了2.42，并且在推理时的实时因子(RTF)为0.15，显著优于之前的扩散模型 E2TTS，后者在处理速度和鲁棒性上存在短板。传统的 TTS 模型往往需要进行复杂的持续时间建模、音素对齐和专门的文本编码，这些都增加了合成过程的复杂性。继续TSS的启动，进入pod 输入命令。
自动化爬虫DrissionPage
m0_55297736的博客
11-09 958
自动化爬虫DrissionPage
什么是Python模块化编程
最新发布
大数据实战派
11-13 321
模块化编程是一种编程方法论，它将程序的功能划分为多个独立的模块，每个模块负责程序中的一部分功能。通过这种方式，程序的代码被分割成更小、更易管理的部分，每个模块都可以独立开发、调试和测试，模块之间通过接口进行交互。模块化编程是将一个复杂的程序拆分为多个独立、功能明确的小模块的编程方法。这不仅提高了代码的复用性和可维护性，还促进了团队协作开发，增强了程序的扩展性。在实际开发中，模块化编程让代码结构更加清晰，逻辑更加简洁，为程序的长久维护和扩展打下了坚实的基础。
外星人入侵
weixin_60243362的博客
11-12 1616
外星人入侵项目实践
推荐一款管道数据检索工具：Pipedata-Pro
11-09 414
是一款专为设计石油、天然气、水和蒸汽管道及管道系统的工程师开发的应用程序。该应用程序提供了设计管道系统所需的工程数据，拥有一个全面的管道类型、配件和材料。
【python基础算法编程】
weixin_42333261的博客
11-12 493
这个函数使用两个指针，一个从字符串的开头开始，另一个从字符串的结尾开始。否则，函数递归调用自身，传入去掉首尾字符的子字符串。递归是一种直接的方法来计算斐波那契数列，但对于较大的 N 值，它会非常慢，因为它会重复计算相同的子问题。然后，它比较字符串的第一个和最后一个字符是否相等。如果它们不相等，函数返回。函数是一个生成器函数，用于生成从给定序列中选择指定长度的元素的所有排列。可以使用循环从最后一个元素开始，逐个访问每个元素，直到第一个元素。斐波那契数列是一个经典的数学序列，其中每个数字都是前两个数字的和。
Windows Update服务设置回自动启动
sinat_38424109的博客
11-08 157
你需要执行相反的操作，即将Windows更新相关的注册表项恢复到默认状态，重新启用计划任务，并将Windows Update服务设置回自动启动。
Python学习笔记：快速掌握Python基础知识
"Python学习笔记" 本笔记主要介绍Python语言的基础知识和应用，适合新手学习和参考。下面是笔记中的一些重要知识点： 1. Python语言介绍：Python是一种自由软件运动的丰硕成果，是一种免费的、解释型的、可移植的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值