Python笔记(四)

最新推荐文章于 2024-05-19 23:31:32 发布
最新推荐文章于 2024-05-19 23:31:32 发布
阅读量890 收藏 20
点赞数 16
分类专栏： Python 文章标签： python 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41878442/article/details/135437117
版权

1. 多任务

多任务是指同一时间内执行多个任务，例如电脑可以同时运行多个软件。
并发是一段时间交替执行任务。并行是同时一起执行多个任务。
实现多任务有两种方式，一种是多进程，另一种是多线程。

1.1 多进程

进程是操作系统进行资源分配和调度运行的基本单位，通俗的说，一个正在运行的程序就是一个进程。

1.1.1 进程创建的步骤

  1. 导入进程模块
  2. 创建进程对象
  3. 启动进程执行任务
import multiprocessing
import time

'''
进程创建的步骤：
1. 导入包
2. 创建进程对象
3. 启动进程执行任务
'''


def playGame():
    for i in range(10):
        print("正在打游戏")
        time.sleep(1)


def listenMusic():
    for i in range(10):
        print("正在听音乐")
        time.sleep(0.5)


if __name__ == '__main__':
	# 创建进程对象
    pro_game = multiprocessing.Process(target=playGame)
    pro_music = multiprocessing.Process(target=listenMusic)
    # 启动进程
    pro_game.start()
    pro_music.start()

在这里插入图片描述

1.1.2 进程传参

创建进程对象的时候，要告诉进程执行的是哪个方法，所以需要添加target参数。
例如：pro_game = multiprocessing.Process(target=playGame)
如果方法需要传递参数，可以添加args或者kwargs来给方法传入参数。
args：通过元组的形式给任务名传递参数，要注意参数的传递顺序
kwargs：通过字典的方式给任务名传递参数，key值要和参数名对应。

import multiprocessing
import time

'''
进程创建的步骤：
1. 导入包
2. 创建进程对象
3. 启动进程执行任务
'''


def playGame(name):
    for i in range(10):
        print(f"正在玩{name}")
        time.sleep(1)


def listenMusic(name):
    for i in range(10):
        print(f"正在听{name}")
        time.sleep(0.5)


if __name__ == '__main__':
    pro_game = multiprocessing.Process(target=playGame, args=('原神',))
    pro_music = multiprocessing.Process(target=listenMusic, kwargs={"name": "《留香》"})
    pro_game.start()
    pro_music.start()

在这里插入图片描述

1.1.3 进程的执行顺序

在程序中创建两个进程后，执行顺序不固定，因为程序是自上而下运行的，所以首先会先执行前面的进程，然后执行后面的进程，但是后面执行进程的顺序就不固定了。

  1. 获取进程编号： os.getpid()
  2. 获取当前父进程编号：os.getppid()
import multiprocessing
import os
import time

'''
进程创建的步骤：
1. 导入包
2. 创建进程对象
3. 启动进程执行任务
'''


def playGame(name):
    for i in range(10):
        print(f"正在玩{name},进程编号是{os.getpid()},父进程编号是{os.getppid()}")
        time.sleep(0.6)


def listenMusic(name):
    for i in range(10):
        print(f"正在听{name},进程编号是{os.getpid()},父进程编号是{os.getppid()}")
        time.sleep(0.5)


if __name__ == '__main__':
    # 获取当前进程的编号
    print(os.getpid())
    pro_game = multiprocessing.Process(target=playGame, args=('原神',))
    pro_music = multiprocessing.Process(target=listenMusic, kwargs={"name": "《留香》"})
    pro_game.start()
    pro_music.start()

在这里插入图片描述

1.1.4 主、子进程相互独立，全局变量不共享

程序执行后，会默认启动一个主进程，然后主进程去创建和执行其余子进程。
程序创建的全局变量，主进程和子进程之间不共享。子进程和子进程之间的全局变量也不共享

import multiprocessing
import os
import time

'''
进程创建的步骤：
1. 导入包
2. 创建进程对象
3. 启动进程执行任务
'''
# 定义全局变量
run_num = 0


def playGame(name):
    for i in range(10):
        global run_num
        print(f"正在玩{name},进程编号是{os.getpid()},父进程编号是{os.getppid()}")
        time.sleep(0.6)
        run_num += 1
        print(f"game进程的run_num的值为：{run_num}")


def listenMusic(name):
    for i in range(10):
        global run_num
        print(f"正在听{name},进程编号是{os.getpid()},父进程编号是{os.getppid()}")
        time.sleep(0.5)
        run_num += 1
        print(f"music进程的run_num的值为：{run_num}")


if __name__ == '__main__':
    # 获取当前进程的编号
    print(os.getpid())
    run_num = 1
    pro_game = multiprocessing.Process(target=playGame, args=('原神',))
    pro_music = multiprocessing.Process(target=listenMusic, kwargs={"name": "《留香》"})
    pro_game.start()
    pro_music.start()
    time.sleep(5)
    print(f"主进程的run_num的值为：{run_num}")

在这里插入图片描述

1.1.5 进程的结束

  1. 默认情况下，主进程会等待所有的子进程执行结束后，再结束。
import multiprocessing
import os
import time

'''
进程创建的步骤：
1. 导入包
2. 创建进程对象
3. 启动进程执行任务
'''
# 定义全局变量
run_num = 0


def playGame(name):
    for i in range(10):
        global run_num
        print(f"正在玩{name},进程编号是{os.getpid()},父进程编号是{os.getppid()}")
        time.sleep(0.6)
        run_num += 1
        print(f"game进程的run_num的值为：{run_num}")
    print("game进程执行完毕")


def listenMusic(name):
    for i in range(10):
        global run_num
        print(f"正在听{name},进程编号是{os.getpid()},父进程编号是{os.getppid()}")
        time.sleep(0.5)
        run_num += 1
        print(f"music进程的run_num的值为：{run_num}")
    print("music进程执行完毕")


if __name__ == '__main__':
    # 获取当前进程的编号
    print(os.getpid())
    run_num = 1
    pro_game = multiprocessing.Process(target=playGame, args=('原神',))
    pro_music = multiprocessing.Process(target=listenMusic, kwargs={"name": "《留香》"})
    pro_game.start()
    pro_music.start()
    time.sleep(3)
    print(f"主进程的run_num的值为：{run_num}")
    print("主进程执行完毕")

在这里插入图片描述

  1. 主进程结束后，立刻杀掉子进程，可以设置守护主进程，即主进程退出后，子进程直接销毁。例如：pro_game.daemon = True
import multiprocessing
import os
import time

'''
进程创建的步骤：
1. 导入包
2. 创建进程对象
3. 启动进程执行任务
'''
# 定义全局变量
run_num = 0


def playGame(name):
    for i in range(10):
        global run_num
        print(f"正在玩{name},进程编号是{os.getpid()},父进程编号是{os.getppid()}")
        time.sleep(0.6)
        run_num += 1
        print(f"game进程的run_num的值为：{run_num}")
    print("game进程执行完毕")


def listenMusic(name):
    for i in range(10):
        global run_num
        print(f"正在听{name},进程编号是{os.getpid()},父进程编号是{os.getppid()}")
        time.sleep(0.5)
        run_num += 1
        print(f"music进程的run_num的值为：{run_num}")
    print("music进程执行完毕")


if __name__ == '__main__':
    # 获取当前进程的编号
    print(os.getpid())
    run_num = 1
    pro_game = multiprocessing.Process(target=playGame, args=('原神',))
    pro_music = multiprocessing.Process(target=listenMusic, kwargs={"name": "《留香》"})
    # 设置守护主进程
    pro_game.daemon = True
    pro_music.daemon = True
    pro_game.start()
    pro_music.start()
    time.sleep(3)
    print(f"主进程的run_num的值为：{run_num}")
    print("主进程执行完毕")

在这里插入图片描述

  1. 除此设置守护主进程外，还可以在退出前，手动销毁子进程。例如：pro_game.terminate()
import multiprocessing
import os
import time

'''
进程创建的步骤：
1. 导入包
2. 创建进程对象
3. 启动进程执行任务
'''
# 定义全局变量
run_num = 0


def playGame(name):
    for i in range(10):
        global run_num
        print(f"正在玩{name},进程编号是{os.getpid()},父进程编号是{os.getppid()}")
        time.sleep(0.6)
        run_num += 1
        print(f"game进程的run_num的值为：{run_num}")
    print("game进程执行完毕")


def listenMusic(name):
    for i in range(10):
        global run_num
        print(f"正在听{name},进程编号是{os.getpid()},父进程编号是{os.getppid()}")
        time.sleep(0.5)
        run_num += 1
        print(f"music进程的run_num的值为：{run_num}")
    print("music进程执行完毕")


if __name__ == '__main__':
    # 获取当前进程的编号
    print(os.getpid())
    run_num = 1
    pro_game = multiprocessing.Process(target=playGame, args=('原神',))
    pro_music = multiprocessing.Process(target=listenMusic, kwargs={"name": "《留香》"})
    # 设置守护主进程
    # pro_game.daemon = True
    # pro_music.daemon = True
    pro_game.start()
    pro_music.start()
    time.sleep(3)
    print(f"主进程的run_num的值为：{run_num}")
    # 手动销毁子进程
    pro_game.terminate()
    pro_music.terminate()
    print("主进程执行完毕")

在这里插入图片描述

1.2 多线程

多线程是实现多任务的另一种方式。

1.2.1 什么是线程

线程是程序执行的最小单位，一个进程中最少有一个线程来负责执行程序。

1.2.2 创建线程的步骤

  1. 导入模块 threading
  2. 创建线程对象
    threading.Thread(target=任务名),其中任务名为函数或者是方法
  3. 启动线程
    线程对象.start()
import os
import threading
import time


def playGame():
    for i in range(10):
        print("正在玩游戏")
        time.sleep(0.6)


def listenMusic():
    for i in range(10):
        print("正在听音乐")
        time.sleep(0.3)


if __name__ == '__main__':
    # 创建线程对象
    th_game = threading.Thread(target=playGame)
    th_music = threading.Thread(target=listenMusic)
    # 启动线程
    th_game.start()
    th_music.start()

在这里插入图片描述

1.2.3 线程的传参

参数传递有两种，分别是：

  1. args 元组的形式传递参数，但是要注意和参数顺序保持一致
  2. kwargs 字典的形式传递参数，要注意字典的key和参数要一一对应。
import os
import threading
import time


def playGame(cont):
    for i in range(10):
        print(f"正在玩{cont}")
        time.sleep(0.6)


def listenMusic(cont):
    for i in range(10):
        print(f"正在听{cont}")
        time.sleep(0.3)


if __name__ == '__main__':
    # 创建线程对象
    th_game = threading.Thread(target=playGame, args=("元梦之星", ))
    th_music = threading.Thread(target=listenMusic, kwargs={"cont": "《萤火飞光》"})
    # 启动线程
    th_game.start()
    th_music.start()

在这里插入图片描述

1.2.4 线程的执行顺序

多个线程之间的执行是无顺序的，是由CPU调度决定的执行顺序。线程的结束顺序和进程类似，也是主线程等待子线程结束后才结束。所以也可以设置守护主线程让主线程结束时，子线程也结束。以下为设置的两种方法：

  1. th_game.daemon = True
  2. th_music.setDaemon(True)
import os
import threading
import time


def playGame(cont):
    for i in range(10):
        print(f"正在玩{cont}")
        time.sleep(0.6)


def listenMusic(cont):
    for i in range(10):
        print(f"正在听{cont}")
        time.sleep(0.3)


if __name__ == '__main__':
    # 创建线程对象
    th_game = threading.Thread(target=playGame, args=("元梦之星", ))
    th_music = threading.Thread(target=listenMusic, kwargs={"cont": "《萤火飞光》"})
    # 设置守护主线程
    th_game.daemon = True
    th_music.setDaemon(True)
    # 启动线程
    th_game.start()
    th_music.start()
    time.sleep(1)
    print("主线程结束")

在这里插入图片描述
查看当前的线程信息：threading.current_thread()

1.2.5 互斥锁

多个线程之间可以共享全局变量，但是这样会出现一个问题，就是实际产生的数据会和预期的产生偏差。解决方法为：要么合理优化时间，让程序交叉运行，要么使用互斥锁。
互斥锁是对共享数据进行锁定，保证同一时刻只有一个线程去操作。
互斥锁的使用方法：

  1. 创建互斥锁 my_lock = threadning.Lock()
  2. 上锁 my_lock.acquire()
  3. 释放锁 my_lock.relase()
    例如：创建两个线程，分别循环累加100万次，最后打印累加次数。
import threading
import time

# 定义全局变量
num = 0


def playGame():
    global num
    for i in range(1000000):
        num += 1
    print(num)


def listenMusic():
    global num
    for i in range(1000000):
        num += 1
    print(num)


if __name__ == '__main__':
    # 创建线程对象
    th_game = threading.Thread(target=playGame)
    th_music = threading.Thread(target=listenMusic)
    # 启动线程
    th_game.start()
    th_music.start()

在这里插入图片描述
正常结果应该是打印2000000
使用互斥锁优化程序：

import threading
import time

# 定义全局变量
num = 0
# 创建锁
my_lock = threading.Lock()


def playGame():
    global num
    for i in range(1000000):
        # 上锁
        my_lock.acquire()
        num += 1
        # 释放锁
        my_lock.release()
    print(num)


def listenMusic():
    global num
    for i in range(1000000):
        # 上锁
        my_lock.acquire()
        num += 1
        # 释放锁
        my_lock.release()
    print(num)


if __name__ == '__main__':
    # 创建线程对象
    th_game = threading.Thread(target=playGame)
    th_music = threading.Thread(target=listenMusic)
    # 启动线程
    th_game.start()
    th_music.start()

在这里插入图片描述

1.2.6 死锁

死锁是指一直等待对方释放锁的情景，死锁会导致程序无法执行。所以在使用锁的时候，要合理的安排释放。

1.3 进程和线程的区别和联系

举个简单的小例子：ceyyen想和山石和海棠聊天。于是打开了两个聊天软件，这就是打开了两个进程。
第二天，ceyyen还是想和山石和海棠聊天，打开了聊天软件的两个窗口，这就是打开了两个线程。
上述例子中，线程明显节约资源。
进程和线程的联系和区别如下：

  1. 线程无法独立运行，线程依附于进程，没有进程就没有线程。
  2. 一个进程可以创建多个线程。
  3. 进程间不共享全局变量，线程之间共享，但是会有资源竞争，可以使用互斥锁解锁。
  4. 创建进程的开销比线程大。进程可以使用多核，线程不能使用。
  5. 进程是操作系统分配的基本单位，线程是CPU调度的基本单位。

2 网络和Socket编程

2.1 网络

网络是实现资源共享和信息传递的虚拟平台。
通过IP可以找到网络中唯一的一台设备，然后与之进行通信。
通过端口号可以找到网络设备种运行的应用程序。
IP地址类型分为IPV4和IPV6，目前使用的主要是IPV4。
在Linux中，可以通过ifconfig命令去查看网卡信息。还可以通过ping命令去检查网络是否连通，以及telnet去检查端口号是否连通。

ping www.baidu.com
telnet 127.0.0.1 8000

2.2 Socket

Socket是程序之间通信的一个工具，遵从TCP传输控制协议。
TCP是面向连接的、可靠的。基于字节流的传输层通信协议。
TCP通信步骤可以总结性的分为3步：

  1. 创建连接
  2. 传输数据
  3. 关闭连接

2.1 TCP客户端

创建一个TCP客户端主要分为以下5步：

  1. 创建客户端套接字对象
my_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 选择IPV4和TCP协议
  1. 和服务端套接字建立连接
my_client.connect(("127.0.0.1", 666))  # 以元组的形式传递连接地址和端口
  1. 发送数据
my_client.send(data.encode("utf-8"))  # 以字节的方式将信息转换
  1. 接收数据
recv_data = my_client.recv(1024).decode("utf-8")  # 将接收的数据转换成对应格式的数据
  1. 关闭套接字
my_client.close()

2.2 TCP服务端

创建一个TCP客户端主要分为以下几步：

  1. 创建服务端套接字对象
my_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  1. 设置端口复用
my_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
  1. 绑定IP和端口号
my_server.bind(("127.0.0.1", 666))
  1. 设置监听
my_server.listen(128)	# 128：代表服务端等待排队连接的最大数量
  1. 等待客户端的连接请求
conn, addr = my_server.accept()
  1. 接收数据
recv_data = con.recv(1024)
  1. 发送数据
con.send(data.encode("utf-8"))
  1. 关闭连接
con.close()
my_server.close()

2.3 聊天功能

利用TCP客户端和TCP服务端可以实现简单的聊天功能。
主要实现思路：

  1. 服务端循环等待客户端的连接请求
  2. 服务端/客户端收发信息全为手工输入
  3. 使用多线程去连接多个客户端
山石满棠
关注
  • 16
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
小甲鱼python教程笔记
08-21
现在更新到序列了，后面会持续更新
中文 Python 笔记
11-03
中文 Python 笔记 中文 Python 笔记 中文 Python 笔记
python基础知识笔记
热门推荐
qq_47541315的博客
10-01 3万+
python基础语法知识总结笔记，视频看的是b站的黑马程序员8天学会Python基础。
[韩顺平]python笔记
weixin_51676760的博客
02-10 2810
程序：计算机执行某些操作或解决某个问题而编写的一系列有序指令的集合。
Python学习笔记
qq_61524266的博客
04-01 6657
python的个人总结
Python学习笔记合集(Pyhton基础总结)
qq_54129105的博客
11-21 2万+
Python学习笔记合集(python基础总结)零基础学python，就来这里看Python学习笔记，简单易懂！
大学python笔记整理_python 笔记整理
weixin_34061440的博客
02-05 2789
Python isdigit() 方法检测字符串是否只由数字组成。Pythonint() 函数用于将一个字符串或数字转换为整型。判断字符、列表、元组等的长度或项目个数：Python len()。enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。(把下标取出来)python中单引号和双引号使用完全相...
Python3 笔记：Python3 在线工具、Python在线编程
Catherine_CSDN_的博客
05-03 1281
在没有安装Python的情况下，想试试在线编程的，推荐以下三款工具： 1、W3Cschool Python 3 在线工具 www.w3cschool.cn/tryrun/runcode?lang=python3 2、Python3 在线工具www.jyshare.com/compile/9/ 3、Python在线编程www.sciclass.cn/python
【超详细】Python基础笔记大全
是小小小酸奶的博客哈哈哈哈哈哈哈，一起加油，一起搞钱！！！
03-12 1573
python基础语法 字面量 常用的值类型 注释 变量 数据类型 type（） 数据类型转换 标识符 运算符 字符串 表达式格式化 数据输入
Python第四周学习笔记
M785418的博客
05-12 2302
Python笔记（3） Python入门
氢键H-H
07-14 1万+
导入模块、缩进、注释、多行语句、Print 输出、等待用户输入
学习python笔记01
qq_44813996的博客
04-11 2970
一、python是什么？ 人生苦短，我用python python是一门解释型语言，边解释边运行，与编译型语言的区别是，编译型语言是先编译后运行。 python语言的特点： 1、优雅 2、明确 3、简单 python是一个完全面向对象语言，具有强大的第三方库。 二、python的基础语法 ...
Python笔记源码python学习
02-27
Python笔记源码python学习
python笔记.md
06-05
python笔记.md
python学习-使用pandas库分析excel表，并导出所需的表
SixSix的自留地
05-16 318
使用pandas库分析excel表中多个子表的数据
python项目如何读取配置文件（配置端口号，ip等等）
weixin_42759398的博客
05-16 264
然后在文件夹内新建一个config.ini。这样就能将配置和代码分离。
使用Python操作excel单元格——在单元格中插入公式
xll_007的博客
05-16 538
使用Python操作excel单元格——在单元格中插入公式。 通过使用Python的openpyxl库，来操作excel单元格，在单元格中插入公式的操作。把学习的过程分享给大家。大佬勿喷！
python数据分析numpy基础之intersect1d求数组交集
最新发布
sinat_34735632的博客
05-19 272
python的numpy库的intersect1d(x,y)函数，计算x和y的公共元素，并返回去重后的有序结果。相当于求两个数组中的交集，并且进行去重和排序。numpy.intersect1()查找两个数组的公共元素，并且返回去重后的有序结果。ar1，ar2：必选，列表、元组、数组；如果是多维则自动转一维数组；assume_unique：可选，bool，默认False，若为True则可以加快计算素材，此时ar1和ar2需为元素唯一的数组，否则结果不会去重；
python 笔记 md
07-14
Python笔记.md 是一个用于记录Python编程相关内容的markdown文档。 在Python学习过程中，学习者通常会遇到各种问题和疑惑，需要有一个地方来记录学习笔记和重要概念，以方便日后复习和查阅。Python笔记.md 就是一个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值