RaspiBerry Blog

分类： Python

  • python扫描机器（电脑、服务器）打开的端口

    """
Code illustration: 7.09
    Port Scanner
Tkinter GUI Application Development Blueprints
"""
import socket
from tkinter import Tk, Label, Entry, Button, Frame, Scrollbar, W, EW, E, Text, \
    DISABLED, Y, BOTH, NORMAL, END
from threading import Thread


class PortScanner():

    stop = False
    url = "google.com"
    start_port = 70
    end_port = 85

    def __init__(self, root):
        self.root = root
        self.create_gui()

    def on_scan_button_clicked(self):
        self.empty_console()
        self.scan_in_a_new_thread()

    def empty_console(self):
        self.console_text.config(state=NORMAL)
        self.console_text.delete("1.0", END)
        self.console_text.config(state=DISABLED)

    def scan_in_a_new_thread(self):
        url = self.host_entry.get()
        start_port = int(self.start_port_entry.get())
        end_port = int(self.end_port_entry.get())
        thread = Thread(target=self.start_scan,
                        args=(url, start_port, end_port))
        thread.start()

    def start_scan(self, url, start_port, end_port):
        for port in range(start_port, end_port + 1):
            if not self.stop:
                self.output_to_console("Scanning port {}".format(port))
                if self.is_port_open(url, port):
                    self.output_to_console(" -- Port {} open \n".format(port))
                else:
                    self.output_to_console("-- Port {} closed \n".format(port))

    def is_port_open(self, url, port):
        try:
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            s.settimeout(1)
            s.connect((socket.gethostbyname(url), port))
            s.close()
            return True
        except:
            return False

    def on_stop_button_clicked(self):
        self.stop = True

    def output_to_console(self, new_text):
        self.console_text.config(state=NORMAL)
        self.console_text.insert(END, new_text)
        self.console_text.see(END)
        self.console_text.config(state=DISABLED)

    def create_gui(self):
        Label(self.root, text='Host :').grid(row="1", column="1", sticky=W)
        self.host_entry = Entry(self.root)
        self.host_entry.insert(0, self.url)
        self.host_entry.grid(row="1", column="2", sticky=EW)
        Label(self.root, text='Start Port :').grid(
            row="2", column="1", sticky=W)
        self.start_port_entry = Entry(self.root)
        self.start_port_entry.insert(0, self.start_port)
        self.start_port_entry.grid(row="2", column="2", sticky=EW)
        Label(self.root, text='End Port :').grid(row="3", column="1", sticky=W)
        self.end_port_entry = Entry(self.root)
        self.end_port_entry.insert(0, self.end_port)
        self.end_port_entry.grid(row="3", column="2", sticky=EW)
        Button(self.root, text='Scan', command=self.on_scan_button_clicked).grid(
            row="4", column="2", sticky=E)
        Button(self.root, text='Stop', command=self.on_stop_button_clicked).grid(
            row="4", column="2", sticky=W)
        Label(self.root, text='Scan Result :').grid(
            row="5", column="1", sticky=W)
        console_frame = Frame(self.root)
        console_frame.grid(row="6", column="1", columnspan="2")
        self.console_text = Text(
            console_frame, fg="green", bg="black", state=DISABLED)
        scrollbar = Scrollbar(console_frame, command=self.console_text.yview)
        scrollbar.pack(side="right", fill=Y)
        self.console_text.pack(expand=1, fill=BOTH)
        self.console_text['yscrollcommand'] = scrollbar.set

if __name__ == '__main__':
    root = Tk()
    PortScanner(root)
    root.mainloop()

  • 使用PyTorch实现线性回归模型的代码

    #使用 PyTorch 实现线性回归模型的代码
import torch
import torch.nn as nn
import  matplotlib.pyplot as plt


# 生成模拟数据
torch.manual_seed(42)
x = torch.linspace(-1, 1, 100).view(-1, 1)
y = 2 * x + 1 + 0.3 * torch.randn(x.size())

# 定义线性回归模型
class LinearRegressionModel(nn.Module):
    def __init__(self):
        super(LinearRegressionModel, self).__init__()
        self.linear = nn.Linear(1, 1)

    def forward(self, x):
        return self.linear(x)

model = LinearRegressionModel()

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

# 训练模型
epochs = 1000
for epoch in range(epochs):
    optimizer.zero_grad()
    outputs = model(x)
    loss = criterion(outputs, y)
    loss.backward()
    optimizer.step()

    if (epoch + 1) % 100 == 0:
        print(f'Epoch [{epoch + 1}/{epochs}], Loss: {loss.item()}')

# 进行预测
with torch.no_grad():
    predicted = model(x)

# 绘制结果
plt.scatter(x.numpy(), y.numpy(), label='True data')
plt.plot(x.numpy(), predicted.numpy(), 'r', label='Predicted')
plt.legend()
plt.show()
'''
在这段代码中，首先生成了模拟的线性数据，并添加了一些噪声。
然后定义了一个线性回归模型，包含一个线性层。
接着使用均方误差损失函数和随机梯度下降优化器进行模型训练。
最后，进行预测并绘制出真实数据和预测结果的对比图。
'''
    #使用 PyTorch 在 GPU 上进行线性回归的代码实例
import torch
import torch.nn as nn
import torch.optim as optim

# 设置设备为 GPU（如果可用）
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f'Using device: {device}')
# 生成模拟数据
torch.manual_seed(42)
x = torch.randn(100, 1).to(device)
y = 3 * x + 2 + torch.randn(100, 1).to(device)

# 定义线性回归模型
class LinearRegression(nn.Module):
    def __init__(self):
        super(LinearRegression, self).__init__()
        self.linear = nn.Linear(1, 1)

    def forward(self, x):
        return self.linear(x)

model = LinearRegression().to(device)

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 训练模型
num_epochs = 1000
for epoch in range(num_epochs):
    # 将数据和模型都移到 GPU
    inputs = x.to(device)
    targets = y.to(device)
    outputs = model(inputs)
    loss = criterion(outputs, targets)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if (epoch + 1) % 100 == 0:
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item()}')

# 在 GPU 上进行预测
with torch.no_grad():
    test_input = torch.tensor([[4.0]]).to(device)
    predicted = model(test_input)
    print(f'Predicted value for input 4.0: {predicted.item()}')

'''
在这个例子中，首先检查是否有可用的 GPU，如果有则将设备设置为 GPU。
然后生成模拟数据并将其移到 GPU 上。定义线性回归模型并将其也移到 GPU。
使用均方误差损失函数和随机梯度下降优化器进行模型训练。最后，在 GPU 上进行预测并输出结果。
'''

    [Running] python -u “d:\python\torch_gpu.py”

    Using device: cpu
    Epoch [100/1000], Loss: 0.917326033115387
    Epoch [200/1000], Loss: 0.7827349305152893
    Epoch [300/1000], Loss: 0.7804043292999268
    Epoch [400/1000], Loss: 0.7803614735603333
    Epoch [500/1000], Loss: 0.7803605794906616
    Epoch [600/1000], Loss: 0.7803605794906616
    Epoch [700/1000], Loss: 0.7803606390953064
    Epoch [800/1000], Loss: 0.7803606390953064
    Epoch [900/1000], Loss: 0.7803606390953064
    Epoch [1000/1000], Loss: 0.7803606390953064

    Predicted value for input 4.0: 14.082897186279297

    [Done] exited with code=0 in 2.915 seconds

  • pyrhon抠图

  • Python的anytree 和 prettytree 两个库来处理和展示树形结构

    要使用 anytree 和 prettytree 两个库来处理和展示树形结构，可以参考以下步骤：

    使用 anytree 创建和遍历树

    1. 安装 anytree： pip install anytree
    2. 创建树结构： 
    from anytree import Node, RenderTree

# 创建节点
root = Node("Root")
child1 = Node("Child1", parent=root)
child2 = Node("Child2", parent=root)
grandchild1 = Node("Grandchild1", parent=child1)

# 渲染树结构
for pre, fill, node in RenderTree(root):
    print(f"{pre}{node.name}")
    1. 安装 prettytree： pip install prettytree
    2. 美化树结构：（这段代码运行出错！！！？？？）
    from prettytree import PrettyTree

# 创建 PrettyTree 对象
tree = PrettyTree("Root")
tree.add_child("Child1").add_child("Grandchild1")
tree.add_child("Child2")

# 打印美化后的树结构
print(tree)

  • python的proxybroker库查找代理资源

    注意此库使用python3.7版，避坑，否则运行时出错！！！

    # 以下是一个使用 Python 的`proxybroker`库结合`tkinter`创建简单图形界面的示例代码，
# 这个界面可以显示找到的代理信息并提供一个按钮来查找新的代理：
# 这个示例代码创建了一个简单的图形界面，
    # 其中包含一个文本框用于显示找到的代理信息，
    # 以及一个按钮用于触发代理查找操作。
# python
import asyncio
import tkinter as tk
from proxybroker import Broker

def display_proxies(proxies):
    for proxy in proxies:
        proxy_info = f'{proxy.type}://{proxy.host}:{proxy.port}'
        proxy_text.insert(tk.END, proxy_info + '\n')

async def find_proxies():
    proxies = []
    broker = Broker()
    found_proxies = await broker.find(types=['HTTP', 'HTTPS'], limit=10)
    for proxy in found_proxies:
        proxies.append(proxy)
    display_proxies(proxies)

def on_find_clicked():
    asyncio.run(find_proxies())

root = tk.Tk()
root.title("Proxy Finder")

proxy_text = tk.Text(root)
proxy_text.pack()

find_button = tk.Button(root, text="Find Proxies", command=on_find_clicked)
find_button.pack()

root.mainloop()

  • 利用scipy进行统计分析

    通常用于统计分析的 Python 库包括 SciPy、Pandas 和 StatsModels 等。以下是如何使用 SciPy 库进行统计分析的示例：

    安装 SciPy 库

    在终端或命令提示符中运行以下命令来安装 SciPy：

    pip install scipy

    使用 SciPy 进行统计分析

    以下是一些常见的统计分析示例：

    1. 描述性统计

    计算数据集的均值、中位数、标准差、偏度和峰度：

    Python

    import numpy as np
    from scipy import stats
    ​
    # 创建一个随机数据集
    data = np.random.randint(0, 100, size=100)
    ​
    # 计算均值
    mean = np.mean(data)
    # 计算中位数
    median = np.median(data)
    # 计算标准差
    std_dev = np.std(data)
    # 计算偏度
    skewness = stats.skew(data)
    # 计算峰度
    kurtosis = stats.kurtosis(data)
    ​
    print("均值:", mean)
    print("中位数:", median)
    print("标准差:", std_dev)
    print("偏度:", skewness)
    print("峰度:", kurtosis)

    AI 生成的代码。仔细查看和使用。 有关常见问题解答的详细信息.

    2. 假设检验

    执行独立样本 t 检验来比较两个样本之间的均值差异：

    Python

    from scipy import stats
    ​
    # 创建两个样本
    sample1 = [1, 2, 3, 4, 5]
    sample2 = [2, 4, 6, 8, 10]
    ​
    # 执行独立样本 t 检验
    t_statistic, p_value = stats.ttest_ind(sample1, sample2)
    ​
    print("t 统计量:", t_statistic)
    print("p 值:", p_value)

    AI 生成的代码。仔细查看和使用。 有关常见问题解答的详细信息.

    3. 回归分析

    进行简单线性回归分析：

    Python

    import numpy as np
    from scipy import stats
    ​
    # 创建两个变量
    x = np.array([1, 2, 3, 4, 5])
    y = np.array([2, 4, 6, 8, 10])
    ​
    # 执行线性回归
    slope, intercept, r_value, p_value, std_err = stats.linregress(x, y)
    ​
    print("斜率:", slope)
    print("截距:", intercept)
    print("相关系数:", r_value)
    print("p 值:", p_value)
    print("标准误差:", std_err)

    全部代码

    #通常用于统计分析的 Python 库包括 `SciPy`、`Pandas` 和 `StatsModels` 等。以下是如何使用 `SciPy` 库进行统计分析的示例：
### 安装 `SciPy` 库
# 在终端或命令提示符中运行以下命令来安装 `SciPy`：
# ```bash
# pip install scipy
# ```
# ### 使用 `SciPy` 进行统计分析
# 以下是一些常见的统计分析示例：
# #### 1. 描述性统计
# 计算数据集的均值、中位数、标准差、偏度和峰度：

import numpy as np
from scipy import stats

# 创建一个随机数据集
data = np.random.randint(0, 100, size=100)

# 计算均值
mean = np.mean(data)
# 计算中位数
median = np.median(data)
# 计算标准差
std_dev = np.std(data)
# 计算偏度
skewness = stats.skew(data)
# 计算峰度
kurtosis = stats.kurtosis(data)

print("均值:", mean)
print("中位数:", median)
print("标准差:", std_dev)
print("偏度:", skewness)
print("峰度:", kurtosis)


#### 2. 假设检验

# 执行独立样本 t 检验来比较两个样本之间的均值差异：

# 创建两个样本
sample1 = [1, 2, 3, 4, 5]
sample2 = [2, 4, 6, 8, 10]

# 执行独立样本 t 检验
t_statistic, p_value = stats.ttest_ind(sample1, sample2)

print("t 统计量:", t_statistic)
print("p 值:", p_value)

# #### 3. 回归分析

# 进行简单线性回归分析：

# 创建两个变量
x = np.array([1, 2, 3, 4, 5])
y = np.array([2, 4, 6, 8, 10])

# 执行线性回归
slope, intercept, r_value, p_value, std_err = stats.linregress(x, y)

print("斜率:", slope)
print("截距:", intercept)
print("相关系数:", r_value)
print("p 值:", p_value)
print("标准误差:", std_err)

  • python的统计分析库scipy.stats

    https://www.doubao.com/thread/w993f77ec171f574e

  • Python搜索附近的WiFi信号

    import pywifi
from pywifi import const

def scan_wifi():
    wifi = pywifi.PyWiFi()
    iface = wifi.interfaces()[0]

    iface.scan()
    scan_results = iface.scan_results()
    for result in scan_results:
        print(f"SSID: {result.ssid}, Signal Strength: {result.signal}")

scan_wifi()

  • Python处理word文档

    https://m.toutiao.com/is/ihH9DAcW/?= CyberPunk:python-docx

    https://github.com/python-openxml/python-docx

  • Python检测数据中的异常值

    import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import IsolationForest
import matplotlib.pyplot as plt

# 创建虚拟数据集
np.random.seed(42)
data = {
    'feature1': np.random.normal(0, 1, 1000),
    'feature2': np.random.normal(0, 1, 1000)
}

# 添加一些异常值
data['feature1'][np.random.randint(0, 1000, 50)] = np.random.uniform(10, 20, 50)
data['feature2'][np.random.randint(0, 1000, 50)] = np.random.uniform(10, 20, 50)

df = pd.DataFrame(data)

# 标准化数据
scaler = StandardScaler()
df_scaled = scaler.fit_transform(df)

# 构建模型
model = IsolationForest(contamination=0.05)
model.fit(df_scaled)

# 检测异常值
df['anomaly'] = model.predict(df_scaled)
df['anomaly'] = df['anomaly'].map({1: 0, -1: 1})  # 1表示正常值，-1表示异常值

# 可视化结果
plt.scatter(df['feature1'], df['feature2'], c=df['anomaly'], cmap='coolwarm')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('Anomaly Detection')
plt.show()