python进阶篇-day05-网络编程(TCP)与进程

于 2024-09-04 20:35:02 发布
阅读量630 收藏 4
点赞数 15
文章标签： python 开发语言 网络协议 网络 tcp numpy httpx
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60916732/article/details/141903261
版权

day05网络编程

一. 网编三要素

ip

概述

设备(电脑, 手机, IPad, 耳机...)在网络中的唯一标识.

分类

按照 代数 划分:

IPv4: 4字节, 十进制来表示, 例如: 192.168.13.157 IPv6: 8字节, 十六进制来表示, 理论上来讲, 可以让地球上的每一粒沙子都有自己的IP.

Ipv4 常用类别划分:

​ 城域网: 第1段是网络地址 + 后3段是主机地址, 例如: 10.0.0.0 广域网: 前2段是网络地址 + 后2段是主机地址, 例如: 10.21.0.0 局域网: 前3段是网络地址 + 后1段是主机地址, 例如: 192.168.13.*

IP相关命令

查看本机的IP: ipconfig 适用于 windows系统 ifconfig 适用于 linux系统, Mac系统测试网络连接是否通畅: ping 主机地址 或者 域名

端口号

端口:

传输数据的通道, 每个程序都有

端口号:

应用程序在设备中的唯一标识

范围:

所有范围: 0 ~ 65535, 但是0 ~ 1023已经被占用(或预留端口),

​ 自己用1024 ~ 65535

协议

UDP: 类似于群聊

  1. 面向无连接

  2. 采用数据包的形式传输数据, 有大小限制(每个包不超过64KB)

  3. 不安全(不可靠)协议

  4. 效率相对较低

  5. 不区分客户端和服务端, 叫: 发送端和接收端

TCP: 类似于打电话

  1. 面向有连接的

  2. 采用 流的方式传输数据, 理论上无大小限制

  3. 安全(可靠)协议

  4. 效率相对较低

  5. 区分客户端和服务器端

查看端口号和协议

netstat -ano

面试题

三次握手

自己:

  1. 客户端请求建立连接

  2. 服务器处理(校验客户端数据是否合法)并发送是否可以建立连接

  3. 服务器允许建立连接 后, 客户端重新请求建立连接通道

讲义:

  1. 客户端向服务端发送请求，等待服务端确认。

  2. 服务端收到请求后知道客户端请求建立连接，回复给客户端以确认连接请求。

  3. 客户端收到确认后，再次发送请求确认服务端，服务端收到正确请求后，如果正确则连接建立成功，完成三次握手，随后客户端与服务端之间可以开始传输数据了。

四次挥手

讲义:

  1. 当主机A（可以是客户端也可以是服务端）完成数据传输后, 提出停止TCP连接的请求

  2. 第二次挥手： 主机B收到请求后对其作出响应，确认这一方向上的TCP连接将关闭

  3. 第三次挥手： 主机B 端再提出反方向的连接关闭请求

  4. 第四次挥手： 主机A对主机B 的请求进行确认，双方向的关闭结束

图解

二. socket套接字

进程之间通信工具

原理

网络通信也叫套接字通信, Socket通信, 即: 通信双方都有自己的Socket对象, 数据在两个Socket之间通过 数据报包 或者 流(字节流) 的方式传输数据

步骤

图解

客户端

步骤

  1. 创建客户端Socket对象.

  2. 连接(服务器端的)ip和端口号, 元组形式.

  3. 发送数据给服务器端.

  4. 接受服务器端发送的数据. 回执信息.

  5. 释放资源.

代码

127.0.0.1 本地回路(回环)地址, 即: 在哪台计算机上运行, 就代表哪台电脑. 简单理解: 代表本机.

import socket
​
# 在main中测试.
if __name__ == '__main__':
    # 1. 创建客户端Socket对象, 指定: 地址族, 传输类型.
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 2. 连接(服务器端)地址和端口.
    # client_socket.connect(("127.0.0.1", 2121))
    client_socket.connect(("192.168.13.157", 2121))
    # 3. 接受服务器端发送的数据并打印.
    # 分解版
    # recv_data_bys = client_socket.recv(1024)
    # recv_data = recv_data_bys.decode("utf-8")
    # 合并版
    recv_data = client_socket.recv(1024).decode("utf-8")
    print(f'客户端收到: {recv_data}')
    # 4. 给服务器端发送数据(回执信息).
    client_socket.send('有内鬼, 终止交易! Over'.encode("utf-8"))
    # 5. 关闭Socket对象.
    client_socket.close()

服务器端

步骤

  1. 创建服务器端Socket对象.

  2. 绑定(服务器端的)ip和端口号, 元组形式.

  3. 设置监听数量.

  4. 等待客户端申请建立连接, 如果有客户端申请建立连接, 校验数据合法后, 会返回1个: (负责和该客户端交互的socket对象, 客户端的信息) 元组

  5. 给客户端发送数据. 字节形式.

  6. 接收客户端发送的数据. 字节形式.

  7. 释放资源.

代码
# 导包.
import socket
​
# 在main中编写.
if __name__ == '__main__':
    # 1. 创建服务器端Socket对象, 指定: 地址族, 传输类型.
    # 参1: IPV4,  参2: 字节流
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 2. 绑定地址和端口.
    # server_socket.bind(("127.0.0.1", 2121))
    server_socket.bind(("192.168.13.157", 2121))
    # 3. 设置监听数量.    范围: 1 ~ 128
    server_socket.listen(5)
    # 4. 等待客户端连接, 如有连接, 则返回: (和客户端交互的Socket对象, 客户端地址)
    print('等待客户端连接中.....')
    # print('Server 1')
    accept_socket, client_info = server_socket.accept()
    # print('Server 2')
    # 5. 给客户端发送数据.
    # accept_socket.send('Welcome to study socket!'.encode('utf-8'))
    accept_socket.send(b'Welcome to study socket!')
​
    # 6. 接受客户端发送的数据并打印.
    recv_data_bys = accept_socket.recv(1024)        # receive: 接收,  一次读取1024个字节
    # 把字节转成字符串, 并打印.
    recv_data = recv_data_bys.decode('utf-8')
    print(f'服务器端收到 {client_info} 发送的信息: {recv_data}')
​
    # 7. 关闭Socket对象.
    accept_socket.close()       # 一般只关闭 和客户端交互的socket对象.
    # server_socket.close()     # 服务器端socket对象一般不关闭.

编解码

概述

编解码指的是 字符串 和 二进制数据之间相互转换.编码: 字符串(我们能看懂的) ==> 二进制(计算机能看懂)解码: 二进制(计算机能看懂) ==> 字符串(我们能看懂的)

细节

  1. 码表 = 字符 + 数字, 即: 码表存储的就是该字符对应的数字.例如(假设): 存数据流程: 中 => 按照码表, 转成123456(十进制) => 0101 1011(二进制, 源码) => 二进制反码 => 二进制补码 => 存储到计算机中. 读数据流程: 读取二进制数据(补码) => 二进制反码 => 二进制源码 => 转成十进制(例如: 123456) => 根据码表, 找到字符 '中'

  2. 在GBK码表(针对于国内)中, 1个中文占2个字节, 在UTF-8码表(万国码, 统一码)中, 中文占3个字节.

  3. 英文字母, 数字, 特殊符号无论在什么码表中, 都只占1个字节.

  4. 如果遇到乱码情况了, 原因只有1个: 编解码不一致.

  5. 针对于二进制数据, 语法糖写法为: b'内容', 但是该形式只针对于 英文字母, 数字, 特殊符号 有效, 针对于中文无效.

代码
# 需求1: 演示编码.
s1 = '黑马aB1!'
bys1 = s1.encode()          # bytes: 字节数组, 默认码表: utf-8
bys2 = s1.encode('gbk')
bys3 = s1.encode('utf-8')
print(f'bys1: {bys1}')  # b'\xe9\xbb\x91\xe9\xa9\xac aB1!'
print(f'bys2: {bys2}')  # b'\xba\xda\xc2\xed aB1!'
print(f'bys3: {bys3}')  # b'\xe9\xbb\x91\xe9\xa9\xac aB1!'
print("-" * 21)
​
# 需求2: 解码
bys4 = b'\xe9\xbb\x91\xe9\xa9\xacaB1!'
s2 = bys4.decode(encoding='utf-8')
s3 = bys4.decode(encoding='gbk')
print(f's2: {s2}')  # 黑马aB1!
print(f's3: {s3}')  # 榛戦┈aB1!
print("-" * 21)
​
# 需求3: 二进制的特殊写法.
bys5 = b'aB1!'
print(type(bys5))   # <class 'bytes'>

端口复用

解释

当服务器端关闭的时候, 端口号释放可能需要1 ~ 2分钟的时间, 如果此时再次开启服务器端, 可能会报: 端口号占用的错误. 解决方案如下: 1. 重新手动更换1个端口号. 2. 设置端口号重用(复用).

server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)

代码
# 导包.
import socket
​
# 在main中编写.
if __name__ == '__main__':
    # 1. 创建服务器端Socket对象, 指定: 地址族, 传输类型.
    # 参1: IPV4,  参2: 字节流
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 2. 绑定地址和端口.
    # server_socket.bind(("127.0.0.1", 2121))
    server_socket.bind(("192.168.13.157", 2121))
    # 3. 设置监听数量.    范围: 1 ~ 128
    server_socket.listen(5)
    # 4. 等待客户端连接, 如有连接, 则返回: (和客户端交互的Socket对象, 客户端地址)
    print('等待客户端连接中.....')
    # print('Server 1')
    accept_socket, client_info = server_socket.accept()
    # print('Server 2')
    # 5. 给客户端发送数据.
    # accept_socket.send('Welcome to study socket!'.encode('utf-8'))
    accept_socket.send(b'Welcome to study socket!')
​
    # 6. 接受客户端发送的数据并打印.
    recv_data_bys = accept_socket.recv(1024)        # receive: 接收,  一次读取1024个字节
    # 把字节转成字符串, 并打印.
    recv_data = recv_data_bys.decode('utf-8')
    print(f'服务器端收到 {client_info} 发送的信息: {recv_data}')
​
    # 7. 关闭Socket对象.
    accept_socket.close()       # 一般只关闭 和客户端交互的socket对象.
    # server_socket.close()     # 服务器端socket对象一般不关闭.
​
    # 8. 设置端口号复用.
    # 参1: 当前的套接字对象.
    # 参2: 参数名, 即: 设置端口号复用.
    # 参3: 参数的值, True: 启用
    server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
​

多客户端

代码
import socket
​
​
def tcp_server():
    # 创建套接字对象
    tss = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 绑定IP与端口号
    tss.bind(('', 2121))
    # 监听客户端连接
    tss.listen(128)
    while True:
        try:
            # 接收客户端信息
            new_s, ip_port = tss.accept()
            # 发送数据给客户端
            new_s.send('back_data'.encode(encoding='utf-8'))
            # 接收客户端信息
            res = new_s.recv(1024)
            res_data = res.decode('utf-8')
            print(f'{ip_port}: {res_data}')
            new_s.close()
            tss.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
        except:
            print('断开连接')
​
​
# 释放资源
tcp_server()
​

长连接

客户端

import socket
​
​
if __name__ == '__main__':
    # 套接字对象
    cli_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 连接服务器端口号
    cli_socket.connect(('127.0.0.1', 6666))
    # 发送信息到服务端
    while True:
        data = input('客户端输入信息:')
        cli_socket.send(data.encode('utf-8'))
        if data == '886':
            break
    cli_socket.close()

服务端

import socket
​
​
if __name__ == '__main__':
    # 套接字对象
    ser_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 绑定端口号
    ser_socket.bind(('127.0.0.1', 6666))
    # 设置监听
    ser_socket.listen(128)
    # 启动监听
    accept_socket, client_info = ser_socket.accept()
    # 发送信息到服务端
    while True:
        recv_data = accept_socket.recv(1024).decode('utf-8')
        print(f'服务端收到信息: {recv_data}')
        if recv_data == '886':
            break
    accept_socket.close()

文件

客户端

import socket
​
​
if __name__ == '__main__':
    # 实例化套接字对象
    cli_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 连接到服务端
    cli_socket.connect(('127.0.0.1', 8848))
    # 读取数据源数据, 并发送到服务端
    with open('data/data.txt', 'rb') as src_f:
        # cli_socket.send('hang.txt'.encode('utf-8'))
        # 分批读取
        while True:
            # 读取数据
            data = src_f.read(1024)
            # 发送到服务器
            cli_socket.send(data)
            # 读取到空结束
            if len(data) <= 0:
                break
    cli_socket.close()

服务端

import socket
​
if __name__ == '__main__':
    # 实例化套接字对象
    ser_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 连接到服务端
    ser_socket.bind(('127.0.0.1', 8848))
    # 设置监听
    ser_socket.listen(1)
    # 启动监听, 等待客户端连接
    accept_socket, client_info = ser_socket.accept()
    # 接收客户端数据
    # 关联目的地文件, 用于把客户端的数据写到文件中
    with open('./data/file.txt', 'wb') as dest_f:
        while True:
            # 接收客户端数据
            res = accept_socket.recv(1024)
            if len(res) <= 0:
                break
            else:
                dest_f.write(res)
    accept_socket.close()

多客户端

服务端

import socket
​
​
if __name__ == '__main__':
    # 实例化套接字对象
    ser_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 连接到服务端(IP可以不写)
    ser_socket.bind(('', 8888))
    # 设置监听
    ser_socket.listen(10)
    # 启动监听, 等待客户端连接
    try:
        cnt = 0
        while True:
            cnt += 1
            filename = './data/文件_'.join(str(cnt) + 'txt')
            accept_socket, client_info = ser_socket.accept()
            # 接收客户端数据
            # 关联目的地文件, 用于把客户端的数据写到文件中
            with open(filename, 'wb') as dest_f:
                while True:
                    res = accept_socket.recv(1024)
                    if len(res) <= 0:
                        break
                    dest_f.write(res)
                accept_socket.send('文件上传成功'.encode('utf-8'))
            print(f'服务器端收到客户端:{client_info}的文件, 接收成功')
            accept_socket.close()
    except:
        pass

三. 进程

每个软件都可以看作是一个进程(数据隔离)

软件内的多个任务可以看作是多个线程(数据共享)

单核CPU: 宏观并行, 微观并发

真正的并行必须有多核CPU

多任务介绍

概述

多任务指的是, 多个任务同时执行

目的

节约资源, 充分利用CPU资源, 提高效率

表现形式

并发

针对于单核CPU来讲, 如果有多个任务同时请求执行, 但是同一瞬间CPU只能执行1个(任务), 于是就安排他们交替执行.

因为时间间隔非常短, 所以宏观上看是并行, 但是微观上还是并发的.

并行

针对多核CPU来讲, 多个任务可以同时执行

进程介绍

概述

进程: 值得是可执行程序, 也是CPU分配资源的最小单位.

线程: 进程的执行路径, 执行单元

解释:

进程: 车

线程: 车道

多进程实现步骤

  1. 导包(multiprocessing)

  2. 创建进程对象, 关联 该进程要执行的任务(函数)

  3. 启动进程执行任务

代码
import multiprocessing, time
​
​
# 定义代码函数
def coding():
    for i in range(1, 21):
        time.sleep(1)
        print(f'正在敲代码----  {i}')
​
        
# 定义音乐函数
def music():
    for i in range(1, 21):
        time.sleep(1)
        print(f'正在听音乐****  {i}')
​
​
if __name__ == '__main__':
    # 创建进程对象
    p1 = multiprocessing.Process(target=coding)
    p2 = multiprocessing.Process(target=music)
    # 执行进程
    p1.start()
    p2.start()

进程参数

参数

target: 用于关联 进程要执行的任务的.name: 进程名, 默认是: Process-1, Process-2,...., 可以手动修改, 一 般不改.args: 可以通过 元组 的形式传递参数, 实参的个数 及 对应的数据类型 要和 形参的个数及类型 一致.kwargs: 可以通过 字典 的形式传递参数, 实参的个数 要和 形参的个数 一致.

代码演示
import multiprocessing, time
​
​
def coding(name, num):
    for i in range(1, num):
        time.sleep(0.01)
        print(f'{name}正在敲第{i}行代码-')
​
​
def music(name, num):
    for i in range(1, num):
        time.sleep(0.01)
        print(f'{name}正在听第{i}首音乐********')
​
​
if __name__ == '__main__':
    p1 = multiprocessing.Process(target=coding, args=('小明', 21))
    p2 = multiprocessing.Process(target=music, kwargs={'num': 21, 'name': '小明'})
    p11 = multiprocessing.Process(target=coding, args=('小明', 21), name='QQ')
    p22 = multiprocessing.Process(target=music, kwargs={'num': 21, 'name': '小明'}, name='WX')
    print(f'p1:{p1.name}')
    print(f'p2:{p2.name}')
    print(f'p11:{p11.name}')
    print(f'p22:{p22.name}')
    p1.start()
    p2.start()
​

main进程

解释

main程序入口也相当于一个进程, 在程序执行时遇到自定义进程会发生资源抢占, 上述代码中在输出进程对象后, 进程才启动, 所以上述的自定义进程不会和main进程强制资源, 并且自定义进程的启动需要一定时间, 此时的main进程可能已经完成自己的任务, 执行自定义进程.

图解

代码
import multiprocessing, time
​
​
def coding(name, num):
    for i in range(1, num):
        time.sleep(0.01)
        print(f'{name}正在敲第{i}行代码-')
​
​
def music(name, num):
    for i in range(1, num):
        time.sleep(0.01)
        print(f'{name}正在听第{i}首音乐********')
​
​
if __name__ == '__main__':
    p1 = multiprocessing.Process(target=coding, args=('小明', 11))
    p2 = multiprocessing.Process(target=music, kwargs={'num': 11, 'name': '小明'})
    # p11 = multiprocessing.Process(target=coding, args=('小明', 11), name='QQ')
    # p22 = multiprocessing.Process(target=music, kwargs={'num': 11, 'name': '小明'}, name='WX')
    p1.start()
    p2.start()
    # print(f'p1:{p1.name}')
    # time.sleep(0.1)
    # print(f'p2:{p2.name}')
    # time.sleep(0.1)
    # print(f'p11:{p11.name}')
    # time.sleep(0.1)
    # print(f'p22:{p22.name}')
​
    for i in range(1, 21):
        print(f'main: -------  {i}')
        time.sleep(0.1)

注: 上述代码中, 若将main中的循环放到自定义进程前, 则自定义进程不会和main抢占资源, 因为执行完main中的循环才执行到自定义进程, 可以把main函数看作栈, 从上到下执行

代码执行结果(每次可能都不一样)

开出南方的花
关注
  • 15
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python系列：【Python】使用python通过TCP或UDP，实现收发报文数据|、Python进阶篇（三）-- TCP套接字与UDP套接字编程
weixin_54626591的博客
12-29 1557
【Python】使用python通过TCP或UDP，实现收发报文数据|、Python进阶篇（三）-- TCP套接字与UDP套接字编程
Python进阶篇（三）-- TCP套接字与UDP套接字编程
CarpeDiem
04-23 2229
本文将首先利用 Python 实现面向TCP连接的套接字编程基础知识：如何创建套接字，将其绑定到特定的地址和端口，以及发送和接收数据包。其次还将学习 HTTP 协议格式的相关知识。在此基础上，本篇将用 Python 语言开发一个简单的 Web 服务器，它仅能处理一个HTTP连接请求。
python100天-Python-100-Days
weixin_37988176的博客
10-30 1573
Python - 100天从新手到大师作者：骆昊最近有很多想学习Python的小伙伴陆陆续续加入我们的交流群，目前我们的交流群人数已经超过一万人，光靠我自己已经无法及时处理小伙伴们的入群申请，更无法及时为大家解答问题。目前我的想法是分技术方向建立讨论群并安排专门的人来管理这些群，群管理者应该具备专业的知识并有相对充裕的时间，可以解答小伙伴们提出的问题。当然，我会向这些管理者支付报酬，如果有兴趣成为...
python-day08网络编程
afd2828的博客
09-03 156
一.楔子 你现在已经学会了写python代码，假如你写了两个python文件a.py和b.py，分别去运行，你就会发现，这两个python的文件分别运行的很好。但是如果这两个程序之间想要传递一个数据，你要怎么做呢？ 这个问题以你现在的知识就可以解决了，我们可以创建一个文件，把a.py想要传递的内容写到文件中，然后b.py从这个文件中读取内容就可以了。 但是当你的a.py和...
Python之路,Day8 - Socket编程进阶
weixin_30765577的博客
05-16 76
本节内容： Socket语法及相关 SocketServer实现多并发　 Socket语法及相关 socket概念 socket本质上就是在2台网络互通的电脑之间，架设一个通道，两台电脑通过这个通道来实现数据的互相传递。 我们知道网络 通信 都 是基于 ip+port 方能定位到目标的具体机器上的具体服务，操作系统有0-65535个端口，每个端口都...
Day8 - Python网络编程 Socket编程
weixin_30908941的博客
12-26 85
Python之路,Day8 - Socket编程进阶 本节内容： Socket语法及相关 SocketServer实现多并发　 Socket语法及相关 socket概念 socket本质上就是在2台网络互通的电脑之间，架设一个通道，两台电脑通过这个通道来实现数据的互相传递。 我们知道网络 通信 都 是基于 ip+p...
python之路：Day8-Socket编程进阶
weixin_33726318的博客
11-29 84
本节内容： 1.Socket语法及相 2.SocketServer实现多并发 Socket语法及相关 socket概念 　　socket本质上就是在两台网络互通的电脑之间，建立一个通道，两台电脑通过这个通道来实现数据的互相传递。我们知道网络通信都给予ip+port方能定位到目标的具体机器上的具体服务...
Python学习-day8 socket进阶
weixin_30485291的博客
04-11 69
还是继续socket网络编程的学习。 socket.socket(family=AF_INET,type=SOCK_STREAM,proto=0,fileno=None) Socket Families(地址簇) socket.AF_UNIX unix本机进程间通信 socket.AF_INET　IPV4　 socket.AF_INET6 IPV6 These consta...
Day16-_20_Python进阶版_
10-03
在“Day16-20_Python进阶版”这个学习资源中，我们可以期待深入探讨Python编程语言的一些高级特性和技巧。在这个阶段的学习中，通常会涵盖以下关键知识点： 1. **函数式编程**：Python支持函数式编程风格，如高阶...
python资料模块三
10-30
`day12 函数高级`和`day21 网络编程（下）`可能涵盖了网络编程的基础知识，如TCP/UDP协议，以及使用Python的`socket`库创建客户端和服务器。网络编程可以让你的程序与其他计算机进行通信，实现数据交换。 `day18 ...
爬虫教程（ 6 ） --- 爬虫 进阶、扩展
墨鱼菜鸡
07-11 6806
1. 前言 1. 先看一个最简单的爬虫。 import requests url = "http://www.cricode.com" r = requests.get(url) print(r.text) 2. 一个正常的爬虫程序 上面那个最简单的爬虫，是一个不完整的残疾的爬虫。因为爬虫程序通常需要做的事情如下： 1)给定的种子 URLs，...
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 558
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
Python的socket库详细介绍
小仙女的博客
09-03 753
socket库是Python标准库的一部分，提供了底层的网络接口，可以用于实现各种网络协议的通信。在网络编程中，socket（套接字）是一种在网络设备之间通信的端点。Python的socket库使得网络编程变得简单且高效，能够处理TCP/IP、UDP等协议。
【扇贝编程】使用Selenium模拟浏览器获取动态内容笔记
最新发布
m0_73676887的博客
09-03 1407
文章目录selenium安装 selenium下载浏览器驱动获取数据处理数据查找一个元素查找所有符合条件的元素控制浏览器 selenium selenium是爬虫的好帮手， 可以控制你的浏览器，模仿人浏览网页，从而获取数据，自动操作等。 我们只要让 selenium 自动控制浏览器，实现爬取数据、自动抢票…… selenium要打开浏览器并控制它，占用的资源会更多，爬取数据的效率也会有所降低。 安装 selenium pip install selenium 下载浏览器驱动 根据你使用的浏览器（如 Chr
CUDA编程08 - 并行编程思维
GPU全栈博主-程序哥
09-02 1087
到目前为止，我们集中于学习并行编程的实用知识，包括CUDA编程接口特性、GPU架构、性能优化技术、并行模式和应用案例研究。在本章中，我们将讨论更为抽象的概念。我们将并行编程概括为一种思维过程，即设计或选择并行算法，并将一个实际问题分解基本的工作单元，这些工作单元可以由所选的算法高效地执行。具备强大思维技能的程序员不仅会分析问题，还会转变实际问题的结构：哪些部分本质上是串行的，哪些部分适合并行执行，以及将前者的部分转移到后者所涉及的一些权衡。
【Python-办公自动化】批量修改EXCEL指定内容
2202_76035290的博客
08-29 3153
欢迎来到"花花 Show Python"，一名热爱编程和分享知识的技术博主。在这里，我将与您一同探索Python的奥秘，分享编程技巧、项目实践和学习心得。无论您是编程新手还是资深开发者，都能在这里找到有价值的信息和灵感。我热衷于将复杂的技术概念以简单易懂的方式呈现给大家，让每个人都能享受到编程的乐趣。我相信，通过不断的学习和实践，我们都能够成为更好的开发者。如果您喜欢我的内容，别忘了点击关注哦！这样您就可以第一时间获取我的更新和分享。您的支持是我不断前进的动力。
Python 高级特效 - 生成器 ( Generator)
weixin_48591974的博客
08-31 508
生成器是一种一边循环一边计算的机制,通过列表生成式，可以直接创建一个列表，但是受到内存的限制，列表容量是有限的，当列表元素很 大的时候，会很浪费内存空间。所以可以通过生成器 Generator 生成，它的作用相比列表，内存占用少，节约资源
【Python报错已解决】`TypeError: ‘numpy.ndarray‘ object is not callable`
鸽芷咕的博客
09-01 422
在编程中，你是否遇到过尝试调用一个Numpy数组对象时出现了`TypeError: 'numpy.ndarray' object is not callable`的报错？这个问题通常是由于误将Numpy数组当成了一个函数来调用。接下来，我们将分析这个问题并提供解决方案。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值