python开发一

最新推荐文章于 2024-09-17 23:15:58 发布

2401_83181186

最新推荐文章于 2024-09-17 23:15:58 发布

阅读量847

点赞数 31

文章标签： python

本文链接：https://blog.csdn.net/2401_83181186/article/details/138506826

版权

python开发一

python的socket模块

语法

1.导入socket模块

import socket

2.创建套接字对象

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

AF_INET表示使用IPv4地址族
SOCK_STREAM表示使用TCP协议，如果需要使用UDP协议，则使用SOCK_DGRAM

3.绑定套接字到IP地址和端口号

sock.bind((host, port))

host是服务器的IP地址（字符串），可以使用空字符串绑定到所有可用的接口上
port是要绑定的端口号（整数）

4.开始监听连接请求

sock.listen(backlog)

backlog是等待连接队列的最大长度

5.接受客户端的连接请求并返回新的套接字和客户端地址信息

client_socket, client_address = sock.accept()

6.发送数据给远程主机

client_socket.send(data)

data是要发送的数据（字符串）

7.接收远程主机发来的数据

data = client_socket.recv(buffer_size)

buffer_size是每次从套接字接收的最大数据量

示例：

import socket

# 创建一个TCP/IP套接字
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 绑定到指定的地址和端口号
host = '127.0.0.1'
port = 12345
server_socket.bind((host, port))

# 开始监听连接请求
server_socket.listen(1)

print("服务器已启动，等待客户端连接...")

while True:
    # 接受一个新的连接请求
    client_socket, client_address = server_socket.accept()
    print("客户端已连接：", client_address)

    # 处理客户端请求
    data = client_socket.recv(1024)
    if data:
        print("接收到消息：", data.decode())
        client_socket.send("Hello, Client!".encode())

    # 关闭客户端连接
    client_socket.close()

获取IP

要获取Python中的IP地址，可以使用socket模块的gethostname()和gethostbyname()函数。

import socket

# 获取主机名
hostname = socket.gethostname()

# 根据主机名获取IP地址
ip_address = socket.gethostbyname(hostname)

print(f"主机名：{hostname}")
print(f"IP地址：{ip_address}")

python的whois模块

语法

1.安装whois模块

pip install python-whois

2.导入whois模块在这里插入代码片

import whois

3.查询域名的WHOIS信息

domain_info = whois.whois(domain)

domain是要查询的域名（字符串）

4.打印WHOIS信息

print(domain_info)

示例：

import whois

# 要查询的域名
domain = "example.com"

# 查询域名的WHOIS信息
domain_info = whois.whois(domain)

# 打印WHOIS信息
print(domain_info)

常用功能

1.获取原始的WHOIS文本：可以使用whois.whois(domain).text来获取原始的WHOIS文本信息，包括所有细节和字段。
2.检查域名是否可用：可以使用whois.query(domain).is_available来检查一个域名是否可用，返回一个布尔值。
3.获取WHOIS服务器：可以使用whois.whois(domain).whois_server来获取用于查询指定域名的WHOIS服务器。
4.获取联系人详细信息：可以使用whois.whois(domain).registrant、whois.whois(domain).admin和whois.whois(domain).tech来获取注册者、管理员和技术联系人的详细信息。
5.解析多个域名的WHOIS信息：可以使用whois.multi_whois(domains)来查询多个域名的WHOIS信息，并返回一个字典，其中键是域名，值是对应的WHOIS信息。
示例：

import whois

# 检查域名是否可用
domain = "example.com"
is_available = whois.query(domain).is_available
print(f"域名 {domain} 是否可用: {is_available}")

# 获取WHOIS服务器
whois_server = whois.whois(domain).whois_server
print(f"域名 {domain} 的WHOIS服务器: {whois_server}")

# 获取联系人详细信息
registrant_info = whois.whois(domain).registrant
print("注册者信息:")
print(registrant_info)

# 解析多个域名的WHOIS信息
domains = ["google.com", "facebook.com", "twitter.com"]
multi_whois = whois.multi_whois(domains)
for domain, info in multi_whois.items():
    print(f"\n域名: {domain}")
    print(info)

可获取的信息

1.域名的注册人（Registrant）
2.注册人的联系方式，如电子邮件、电话号码等
3.域名的注册商（Registrar）
4.域名的注册日期和到期日期
5.DNS服务器信息
6.域名的状态（是否已注册、是否可用等）

下面是一些常见的WHOIS对象属性：

domain_name：域名的名称
registrar：域名的注册商
whois_server：用于查询该域名的WHOIS服务器
referral_url：WHOIS查询的引用URL
registrant：域名的注册者
admin：域名的管理员联系信息
tech：域名的技术联系信息
name_servers：域名的DNS服务器列表
creation_date：域名的注册日期
expiration_date：域名的到期日期
status：域名的状态
示例：

import whois

# 要查询的域名
domain = "example.com"

# 查询域名的WHOIS信息
domain_info = whois.whois(domain)

# 打印一些属性
print("域名名称:", domain_info.domain_name)
print("注册商:", domain_info.registrar)
print("注册日期:", domain_info.creation_date)
print("到期日期:", domain_info.expiration_date)
print("DNS服务器:", domain_info.name_servers)

python的sys模块

命令行参数：

sys.argv：表示一个包含命令行参数的列表。其中sys.argv[0]是脚本的名称，后续元素是传递给脚本的参数。

标准输入输出：

sys.stdin：表示标准输入流。
sys.stdout：表示标准输出流。
sys.stderr：表示标准错误流。

退出程序：

sys.exit([status])：用于退出程序。可选的status参数指定退出状态码，默认为0。

运行时环境和系统相关信息：

sys.version：返回Python解释器的版本信息。
sys.platform：返回当前平台的标识符（如’win32’，'linux’等）。
sys.getsizeof(object)：返回对象占用的内存大小（以字节为单位）。
sys.modules：是一个字典，包含已导入的模块。
示例：

import sys

# 获取命令行参数
print("命令行参数:")
for arg in sys.argv:
    print(arg)

# 打印到标准输出
sys.stdout.write("这是标准输出\n")

# 打印到标准错误
sys.stderr.write("这是标准错误\n")

# 退出程序
sys.exit(1)

# 输出Python解释器版本信息
print("Python解释器版本:", sys.version)

# 输出当前平台标识符
print("当前平台:", sys.platform)

# 获取对象占用的内存大小
my_list = [1, 2, 3, 4, 5]
print("my_list占用的内存大小:", sys.getsizeof(my_list))

# 获取已导入的模块
print("已导入的模块:", list(sys.modules.keys()))

python的threading模块

Python的threading模块提供了一个高级别的多线程编程接口，用于在Python中进行并发编程。它允许你使用多个线程同时执行任务，从而实现并行处理和提高程序的性能。以下是threading模块的一些常见功能：

创建和管理线程：

Thread类：表示一个线程对象。可以通过继承Thread类或传递可调用对象来创建自定义的线程。
start()方法：启动线程，使其开始执行。
join([timeout])方法：等待线程执行完成。可选的timeout参数指定等待时间。
name属性：获取或设置线程的名称。

线程同步和互斥：

Lock类：提供基本的互斥锁功能，用于控制多个线程对共享资源的访问。
RLock类：可重入锁，允许同一个线程多次获取锁。
Condition类：提供条件变量，用于线程之间的通信和同步。
Semaphore类：实现信号量机制，用于控制对共享资源的访问权限。
示例：

import threading
import time

# 自定义线程类
class MyThread(threading.Thread):
    def __init__(self, name):
        super().__init__()
        self.name = name
    
    def run(self):
        print("线程", self.name, "开始执行")
        time.sleep(2)
        print("线程", self.name, "执行完成")

# 创建线程对象
thread1 = MyThread("Thread 1")
thread2 = MyThread("Thread 2")

# 启动线程
thread1.start()
thread2.start()

# 等待线程执行完成
thread1.join()
thread2.join()

print("所有线程执行完成")

常用功能

线程间通信：

Event类：提供了一个简单的线程事件对象，用于线程之间的通信和同步。
Condition类：除了互斥锁外，它还提供了线程等待和唤醒机制，用于复杂的线程间协调。
Queue类：提供线程安全的队列，用于在线程之间传递数据。

线程池：

ThreadPoolExecutor类：提供了一种方便的方式来管理和执行线程池中的任务，从而降低线程创建和销毁的开销。

线程优先级：

threading.Thread类的priority属性：用于获取或设置线程的优先级。不同平台的线程优先级支持度可能有所不同。

线程间同步：

Lock类、RLock类和Semaphore类：在处理共享资源时，可以使用这些同步原语来确保线程安全。
示例：

import threading
import time

# 线程之间通信
def worker(event):
    print("Worker线程等待事件触发")
    event.wait()
    print("Worker线程收到事件")

def main():
    # 创建事件对象
    event = threading.Event()

    # 创建Worker线程并启动
    thread = threading.Thread(target=worker, args=(event,))
    thread.start()

    # 主线程延迟一段时间后触发事件
    time.sleep(2)
    print("主线程触发事件")
    event.set()

    # 等待Worker线程结束
    thread.join()


# 线程池
from concurrent.futures import ThreadPoolExecutor

def task(name):
    print(f"任务 {name} 开始执行")
    time.sleep(2)
    print(f"任务 {name} 执行完成")

def main_pool():
    # 创建线程池
    with ThreadPoolExecutor(max_workers=3) as executor:
        # 提交任务到线程池
        executor.submit(task, "Task 1")
        executor.submit(task, "Task 2")
        executor.submit(task, "Task 3")

        # 等待所有任务完成
        executor.shutdown(wait=True)

# 设置线程优先级
thread = threading.Thread(target=task)
thread.priority = 1

# 使用同步原语
lock = threading.Lock()
with lock:
    # 临界区代码
    pass

python的queue模块

常用

Queue: 这是最常用的队列类，实现了一个基本的先进先出（FIFO）队列。可以使用put()方法将元素添加到队列中，get()方法从队列中获取元素。
LifoQueue: 该类实现了一个后进先出（LIFO）队列，也称为堆栈。使用方式与Queue类相似。
PriorityQueue: 该类实现了一个优先级队列，每个元素会有一个与之关联的优先级。使用方式与Queue类相似，但是可以通过指定优先级来控制元素的顺序。
除了上述几个类之外，queue 模块还提供了其他一些辅助函数，例如：
empty(): 判断队列是否为空。
full(): 判断队列是否已满。
qsize(): 返回队列中元素的数量。
put_nowait(item): 将元素添加到队列中，如果队列已满则立即引发 Queue.Full 异常。
get_nowait(): 从队列中获取元素，如果队列为空则立即引发 Queue.Empty 异常。

使用 Queue 类实现先进先出（FIFO）队列

import queue

q = queue.Queue()

# 添加元素到队列
q.put(10)
q.put(20)
q.put(30)

# 从队列中获取元素
print(q.get())  # 输出：10
print(q.get())  # 输出：20
print(q.get())  # 输出：30

使用 LifoQueue 类实现后进先出（LIFO）队列（堆栈）

import queue

stack = queue.LifoQueue()

# 添加元素到堆栈
stack.put(10)
stack.put(20)
stack.put(30)

# 从堆栈中获取元素
print(stack.get())  # 输出：30
print(stack.get())  # 输出：20
print(stack.get())  # 输出：10

使用 PriorityQueue 类实现优先级队列

import queue

pq = queue.PriorityQueue()

# 添加带有优先级的元素到队列
pq.put((3, "Apple"))
pq.put((1, "Banana"))
pq.put((2, "Orange"))

# 从队列中获取元素按优先级顺序返回
print(pq.get())  # 输出：(1, 'Banana')
print(pq.get())  # 输出：(2, 'Orange')
print(pq.get())  # 输出：(3, 'Apple')

python的time模块

time(): 返回从 1970 年 1 月 1 日开始累计的秒数，也称为 UNIX 时间戳。
ctime(): 返回当前时间的可读字符串表示。
gmtime([secs]): 将一个时间戳转换为格林威治天文时间（GMT）的结构化时间对象。
localtime([secs]): 将一个时间戳转换为本地时间的结构化时间对象。
asctime([tupletime]): 接受一个由 9 个元素组成的时间元组，并返回一个可读的字符串表示该时间。
strftime(format[, t]): 根据指定的格式化字符串，将时间转换为自定义的字符串表示。
sleep(secs): 在指定的秒数内暂停程序执行。
示例：
1.获取当前时间和日期

import time

current_time = time.time()
print("当前时间戳：", current_time)

current_local_time = time.ctime()
print("当前本地时间：", current_local_time)

current_gmt_time = time.gmtime()
print("当前格林威治时间：", current_gmt_time)

2.格式化时间

import time

current_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
print("当前格式化时间：", current_time)

3.暂停程序执行

import time

print("开始...")
time.sleep(5)  # 暂停 5 秒
print("结束!")

2401_83181186

关注

31
点赞
踩
8

收藏

觉得还不错? 一键收藏
3
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫